home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1997 #1 / Amiga Plus CD - 1997 - No. 01.iso / pd / programmierung / mesa-1.2.8 / src / list.c < prev    next >
C/C++ Source or Header  |  1996-05-27  |  70KB  |  3,075 lines
  1. /* $Id: list.c,v 1.41 1996/05/20 15:21:44 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  1.2
  6.  * Copyright (C) 1995-1996  Brian Paul  (brianp@ssec.wisc.edu)
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25. $Log: list.c,v $
  26.  * Revision 1.41  1996/05/20  15:21:44  brianp
  27.  * replaced Reserved[] array with empty lists, fixed glIsList bug()
  28.  *
  29.  * Revision 1.40  1996/05/01  20:46:01  brianp
  30.  * added GL_MESA_window_pos extension code
  31.  *
  32.  * Revision 1.39  1996/04/23  22:12:46  brianp
  33.  * use new CC.VertexFunc logic
  34.  * added gl_print_list()
  35.  *
  36.  * Revision 1.38  1996/03/18  13:47:06  brianp
  37.  * fixed glHint() display list bug
  38.  *
  39.  * Revision 1.37  1996/03/15  16:24:57  brianp
  40.  * fixed problem with glClearStencil() in display lists
  41.  *
  42.  * Revision 1.36  1996/02/26  15:10:12  brianp
  43.  * use CC.Current.IntColor instead of CC.Current.Color
  44.  *
  45.  * Revision 1.35  1996/02/02  23:22:13  brianp
  46.  * check for valid display list number in glDeleteLists()
  47.  *
  48.  * Revision 1.34  1995/12/30  17:17:56  brianp
  49.  * added direct glScale and glTranslate support
  50.  *
  51.  * Revision 1.33  1995/12/30  00:55:39  brianp
  52.  * compute CC.Current.IntColor for glColor
  53.  *
  54.  * Revision 1.32  1995/12/20  17:28:44  brianp
  55.  * dont' call gl_color or gl_index anymore, inlined their operations
  56.  *
  57.  * Revision 1.31  1995/12/19  17:06:44  brianp
  58.  * added gl_save_blendcolor, blendequation, colormaterial, edge_flag, matrixmode
  59.  * removed gl_save_set_boolean, enum, float, int, uint
  60.  *
  61.  * Revision 1.30  1995/12/19  16:42:20  brianp
  62.  * added gl_save_pixeltransfer
  63.  *
  64.  * Revision 1.29  1995/11/03  17:38:16  brianp
  65.  * removed unused variables, added casts for C++ compilation
  66.  *
  67.  * Revision 1.28  1995/11/02  14:56:31  brianp
  68.  * added several (Node *) casts per Steven Spitz
  69.  *
  70.  * Revision 1.27  1995/10/29  19:14:19  brianp
  71.  * added glPolygonOffsetEXT display list support
  72.  *
  73.  * Revision 1.26  1995/10/14  17:42:12  brianp
  74.  * added glClipPlane, glLightModel, and texture functions
  75.  *
  76.  * Revision 1.25  1995/10/04  19:35:07  brianp
  77.  * replaced gl_save_normal with gl_save_normal3fv and gl_save_normal3f
  78.  *
  79.  * Revision 1.24  1995/08/31  18:34:16  brianp
  80.  * added display list / glScissor support
  81.  *
  82.  * Revision 1.23  1995/08/01  21:51:40  brianp
  83.  * renamed gl_save_pixelZoom as gl_save_pixelzoom
  84.  *
  85.  * Revision 1.22  1995/08/01  20:53:35  brianp
  86.  * added glPixelZoom support
  87.  *
  88.  * Revision 1.21  1995/07/25  16:41:54  brianp
  89.  * made changes for using CC.VertexFunc pointer
  90.  *
  91.  * Revision 1.20  1995/07/24  20:34:16  brianp
  92.  * replaced memset() with MEMSET() and memcpy() with MEMCPY()
  93.  *
  94.  * Revision 1.19  1995/06/22  14:28:20  brianp
  95.  * added glStencilFunc, glStencilMask and glStencilOp support
  96.  *
  97.  * Revision 1.18  1995/06/12  15:52:56  brianp
  98.  * changed includes for copypix.h and drawpix.h
  99.  *
  100.  * Revision 1.17  1995/05/22  21:02:41  brianp
  101.  * Release 1.2
  102.  *
  103.  * Revision 1.16  1995/05/19  13:26:50  brianp
  104.  * added display list support for selection/name stack functions
  105.  *
  106.  * Revision 1.15  1995/05/18  14:46:19  brianp
  107.  * fixed texture deallocation infinite loop bug
  108.  *
  109.  * Revision 1.14  1995/05/17  13:16:26  brianp
  110.  * added more error checking:  GL_INVALID_OPERATION between begin/end
  111.  *
  112.  * Revision 1.13  1995/05/15  16:07:15  brianp
  113.  * implemented shared/nonshared display lists
  114.  *
  115.  * Revision 1.12  1995/05/12  16:57:22  brianp
  116.  * replaced CC.Mode!=0 with INSIDE_BEGIN_END
  117.  *
  118.  * Revision 1.11  1995/05/10  18:44:40  brianp
  119.  * added glTexImage support
  120.  *
  121.  * Revision 1.10  1995/04/19  13:48:18  brianp
  122.  * renamed occurances of near and far for SCO x86 Unix
  123.  *
  124.  * Revision 1.9  1995/04/08  15:26:37  brianp
  125.  * add gl_save_shademodel
  126.  *
  127.  * Revision 1.8  1995/03/13  15:58:23  brianp
  128.  * fixed bitmap bugs per Thorsten Ohl
  129.  *
  130.  * Revision 1.7  1995/03/09  19:06:05  brianp
  131.  * replaced gl_disable calls with gl_enable(GL_FALSE)
  132.  *
  133.  * Revision 1.6  1995/03/08  15:10:02  brianp
  134.  * added logicop and clear_index functions
  135.  *
  136.  * Revision 1.5  1995/03/04  19:29:44  brianp
  137.  * 1.1 beta revision
  138.  *
  139.  * Revision 1.4  1995/03/01  15:23:53  brianp
  140.  * fixed glListBase, glCallList, glCallLists semantics bug
  141.  *
  142.  * Revision 1.3  1995/02/24  17:27:40  brianp
  143.  * *** empty log message ***
  144.  *
  145.  * Revision 1.2  1995/02/24  15:28:00  brianp
  146.  * fixed destroy_list bug
  147.  *
  148.  * Revision 1.1  1995/02/24  14:24:47  brianp
  149.  * Initial revision
  150.  *
  151.  */
  152.  
  153.  
  154. /*
  155.  * display lists.
  156.  */
  157.  
  158.  
  159. #include <stdio.h>
  160. #include <stdlib.h>
  161. #include <string.h>
  162. #include "accum.h"
  163. #include "attrib.h"
  164. #include "bitmap.h"
  165. #include "clip.h"
  166. #include "context.h"
  167. #include "copypix.h"
  168. #include "draw.h"
  169. #include "drawpix.h"
  170. #include "enable.h"
  171. #include "eval.h"
  172. #include "feedback.h"
  173. #include "fog.h"
  174. #include "light.h"
  175. #include "logic.h"
  176. #include "macros.h"
  177. #include "pixel.h"
  178. #include "texture.h"
  179. #include "vb.h"
  180. #include "xform.h"
  181.  
  182.  
  183. /*
  184. public        list building        internal    display list
  185. gl function    function        function    node kind
  186. ----------------------------------------------------------------------
  187. glAccum        gl_save_acum        <same>        NODE_ACCUM
  188. glAlphaFunc    gl_save_alphafunc    <same>        NODE_ALPHA_FUNC
  189. glBegin        gl_save_begin        gl_begin    NODE_BEGIN
  190. glBitmap    gl_save_bitmap        gl_bitmap    NODE_BITMAP
  191. glBlendColor    gl_save_blendcolor      <same>          NODE_BLEND_COLOR
  192. glBlendEquation gl_save_blendequation   <same>          NODE_BLEND_EQUATION
  193. glBlendFunc    gl_save_blendfunc    <same>        NODE_BLEND_FUNC
  194. glCallList    gl_save_call        execute_list    NODE_CALL_LIST
  195. glCallLists    gl_save_call        execute_list    NODE_CALL_LIST_OFFSET
  196. glClear        gl_save_clear        gl_clear    NODE_CLEAR
  197. glClearAccum    gl_save_clearaccum    <same>        NODE_CLEAR_ACCUM
  198. glClearColor    gl_save_clearcolor    <same>        NODE_CLEAR_COLOR
  199. glClearDepth    gl_save_cleardepth    <same>        NODE_CLEAR_DEPTH
  200. glClearIndex    gl_save_clearindex    <same>        NODE_CLEAR_INDEX
  201. glClearStencil    gl_save_clearstencil    <same>        NODE_CLEAR_STENCIL
  202. glClipPlane     gl_save_clipplane       gl_clipplane    NODE_CLIP_PLANE
  203. glColor*    gl_save_color        gl_color    NODE_COLOR
  204. glColorMask    gl_save_colormask    <same>        NODE_COLOR_MASK
  205. glColorMaterial    gl_save_colormaterial    <same>        NODE_COLOR_MATERIAL
  206. glCopyPixels    gl_save_copypixels    gl_copypixels    NODE_COPY_PIXELS
  207. glCullFace    gl_save_cullface    <same>        NODE_CULL_FACE
  208. glDepthFunc    gl_save_depthfunc    <same>        NODE_DEPTH_FUNC
  209. glDepthMask    gl_save_depthmask    <same>        NODE_DEPTH_MASK
  210. glDepthRange    gl_save_depthrange    <same>        NODE_DEPTH_RANGE
  211. glDisable    gl_save_disable        gl_enable    NODE_DISABLE
  212. glDrawBuffer    gl_save_drawbuffer    <same>        NODE_DRAW_BUFFER
  213. glDrawPixels    gl_save_drawpixels    gl_drawpixels    NODE_DRAW_PIXELS
  214. glEdgeFlag*    gl_save_edgeflag        <none>          NODE_EDGE_FLAG
  215. glEnable    gl_save_enable        gl_enable    NODE_ENABLE
  216. glEnd        gl_save_end        gl_end        NODE_END
  217. glEvalCoord1f    gl_save_evalcoord1    gl_evalcoord1    NODE_EVALCOORD1
  218. glEvalCoord1d    gl_save_evalcoord1    gl_evalcoord1    NODE_EVALCOORD1
  219. glEvalCoord2f    gl_save_evalcoord2    gl_evalcoord2    NODE_EVALCOORD2
  220. glEvalCoord2d    gl_save_evalcoord2    gl_evalcoord2    NODE_EVALCOORD2
  221. glEvalPoint1    gl_save_evalpoint1    <same>        NODE_EVALPOINT1
  222. glEvalPoint2    gl_save_evalpoint2    <same>        NODE_EVALPOINT2
  223. glEvalMesh1    gl_save_evalmesh1    <same>        NODE_EVALMESH1
  224. glEvalMesh2    gl_save_evalmesh2    <same>        NODE_EVALMESH2
  225. glFog        gl_save_fog        gl_fog        NODE_FOG
  226. glFrontFace    gl_save_frontface    <same>        NODE_FRONT_FACE
  227. glHint        gl_save_hint        <same>        NODE_HINT
  228. glIndex*    gl_save_index        gl_index    NODE_INDEX
  229. glIndexMask    gl_save_indexmask    <same>        NODE_INDEX_MASK
  230. glInitNames    gl_save_initnames    <same>        NODE_INIT_NAMES
  231. glLight*    gl_save_light        gl_light    NODE_LIGHT
  232. glLightModel*    gl_save_lightmodel    gl_lightmodel    NODE_LIGHT_MODEL
  233. glLineStipple    gl_save_linestipple    gl_line_stipple    NODE_LINE_STIPPLE
  234. glLineWidth    gl_save_linewidth    gl_line_width    NODE_LINE_WIDTH
  235. glListBase    gl_save_listbase    <same>        NODE_LIST_BASE
  236. glLoadMatrix    gl_save_loadmatrix    gl_load_matrix    NODE_LOAD_MATRIX
  237. glLoadName    gl_save_loadname    <same>        NODE_LOAD_NAME
  238. glLogicOp    gl_save_logicop        gl_logicop    NODE_LOGIC_OP
  239. glMap1f        gl_save_map1        gl_map1        NODE_MAP1
  240. glMap1d        gl_save_map1        gl_map1        NODE_MAP1
  241. glMap2f        gl_save_map2        gl_map2        NODE_MAP2
  242. glMap2d        gl_save_map2        gl_map2        NODE_MAP2
  243. glMapGrid1f    gl_save_mapgrid1    gl_mapgrid1    NODE_MAPGRID1
  244. glMapGrid1d    gl_save_mapgrid1    gl_mapgrid1    NODE_MAPGRID1
  245. glMapGrid2f    gl_save_mapgrid2    gl_mapgrid2    NODE_MAPGRID2
  246. glMapGrid2d    gl_save_mapgrid2    gl_mapgrid2    NODE_MAPGRID2
  247. glMaterial*    gl_save_material    gl_material    NODE_MATERIAL
  248. glMatrixMode    gl_save_matrixmode      <same>          NODE_MATRIX_MODE
  249. glMultMatrix    gl_save_multmatrix    gl_mult_matrix    NODE_MULT_MATRIX
  250. glNormal*    gl_save_normal        <none>        NODE_NORMAL
  251. glPassThrough    gl_save_passthrough    gl_passthrough    NODE_PASSTHROUGH
  252. glPixelMap    gl_save_pixelmap    gl_pixel_map    NODE_PIXEL_MAP
  253. glPixelTransfer gl_save_pixeltransfer   gl_pixel_transfer NODE_PIXEL_TRANSFER
  254. glPixelZoom    gl_save_pixelzoom    <same>        NODE_PIXEL_ZOOM
  255. glPointSize    gl_save_pointsize    <same>       NODE_POINTSIZE
  256. glPolygonMode    gl_save_polygonmode    <same>        NODE_POLYGON_MODE
  257. glPolygonOffset gl_save_polygonoffset   <same>          NODE_POLYGON_OFFSET
  258. glPopAttrib    gl_save_popmatrix    gl_pop_attrib    NODE_POP_ATTRIB
  259. glPopMatrix    gl_save_popmatrix    gl_pop_matrix    NODE_POP_MATRIX
  260. glPopName    gl_save_popname        <same>        NODE_POP_NAME
  261. glPushAttrib    gl_save_pushmatrix    gl_push_attrib    NODE_PUSH_ATTRIB
  262. glPushMatrix    gl_save_pushmatrix    gl_push_matrix    NODE_PUSH_MATRIX
  263. glPushName    gl_save_pushname    <same>        NODE_PUSH_NAME
  264. glRasterPos*    gl_save_rasterpos    gl_rasterpos    NODE_RASTER_POS
  265. glReadBuffer    gl_save_readbuffer    <same>        NODE_READ_BUFFER
  266. glScale*        gl_save_scale           gl_scale        NODE_SCALE
  267. glScissor       gl_save_scissor         <same>          NODE_SCISSOR
  268. glShadeModel    gl_save_shademodel    <same>        NODE_SHADE_MODEL
  269. glStencilFunc    gl_save_stencilfunc    <same>        NODE_STENCIL_FUNC
  270. glStencilMask    gl_save_stencilmask    <same>        NODE_STENCIL_MASK
  271. glStencilOp    gl_save_stencilop    <same>        NODE_STENCIL_OP
  272. glTexCoord*    gl_save_texcoord    <none>        NODE_TEXCOORD
  273. glTexEnv*       gl_save_texenv          gl_texinv       NODE_TEXENV
  274. glTexGen*       gl_save_texgen          gl_texgen       NODE_TEXGEN
  275. glTexParam*     gl_save_texparameter    gl_texparameter NODE_TEXPARAMETER
  276. glTexImage1D    gl_save_teximage1d    gl_teximage1d    NODE_TEXIMAGE1D
  277. glTexImage2D    gl_save_teximage2d    gl_teximage2d    NODE_TEXIMAGE2D
  278. glTranslate*    gl_save_translate       gl_translate    NODE_TRANSLATE
  279. glVertex*    gl_save_vertex        gl_vertex    NODE_VERTEX
  280. glViewport    gl_save_viewport    gl_viewport    NODE_VIEWPORT
  281. glWindowPos*    gl_save_windowpos    gl_windowpos    NODE_WINDOW_POS
  282. */
  283.  
  284.  
  285. /*
  286. Functions which aren't compiled but executed immediately:
  287.     glIsList
  288.     glGenLists
  289.     glDeleteLists
  290.     glEndList
  291.     glFeedbackBuffer
  292.     glSelectBuffer
  293.     glRenderMode
  294.     glReadPixels
  295.     glPixelStore
  296.     glFlush
  297.     glFinish
  298.     glIsEnabled
  299.     glGet*
  300.  
  301. Functions which cause errors if called while compile a display list:
  302.     glNewList
  303. */
  304.  
  305.  
  306.  
  307. /* How many nodes to allocate at a time: */
  308. #define BLOCK_SIZE 500
  309.  
  310.  
  311. /*
  312.  * Kinds of nodes:  (the fact that these identifiers are assigned consecutive
  313.  * integer values starting at 0 is very important, see NodeSize array usage)
  314.  */
  315. typedef enum {
  316.     NODE_ACCUM,
  317.     NODE_ALPHA_FUNC,
  318.         NODE_BEGIN,
  319.     NODE_BITMAP,
  320.     NODE_BLEND_COLOR,
  321.     NODE_BLEND_EQUATION,
  322.     NODE_BLEND_FUNC,
  323.         NODE_CALL_LIST,
  324.         NODE_CALL_LIST_OFFSET,
  325.     NODE_CLEAR,
  326.     NODE_CLEAR_ACCUM,
  327.     NODE_CLEAR_COLOR,
  328.     NODE_CLEAR_DEPTH,
  329.     NODE_CLEAR_INDEX,
  330.     NODE_CLEAR_STENCIL,
  331.         NODE_CLIP_PLANE,
  332.     NODE_COLOR,
  333.     NODE_COLOR_MASK,
  334.     NODE_COLOR_MATERIAL,
  335.     NODE_COPY_PIXELS,
  336.     NODE_CULL_FACE,
  337.     NODE_DEPTH_FUNC,
  338.     NODE_DEPTH_MASK,
  339.     NODE_DEPTH_RANGE,
  340.     NODE_DISABLE,
  341.     NODE_DRAW_BUFFER,
  342.     NODE_DRAW_PIXELS,
  343.         NODE_EDGE_FLAG,
  344.     NODE_ENABLE,
  345.         NODE_END,
  346.     NODE_EVALCOORD1,
  347.     NODE_EVALCOORD2,
  348.     NODE_EVALMESH1,
  349.     NODE_EVALMESH2,
  350.     NODE_EVALPOINT1,
  351.     NODE_EVALPOINT2,
  352.     NODE_FOG,
  353.     NODE_FRONT_FACE,
  354.     NODE_HINT,
  355.     NODE_INDEX,
  356.     NODE_INDEX_MASK,
  357.     NODE_INIT_NAMES,
  358.     NODE_LIGHT,
  359.     NODE_LIGHT_MODEL,
  360.     NODE_LINE_STIPPLE,
  361.     NODE_LINE_WIDTH,
  362.     NODE_LIST_BASE,
  363.     NODE_LOAD_MATRIX,
  364.     NODE_LOAD_NAME,
  365.     NODE_LOGIC_OP,
  366.     NODE_MAP1,
  367.     NODE_MAP2,
  368.     NODE_MAPGRID1,
  369.     NODE_MAPGRID2,
  370.     NODE_MATERIAL,
  371.     NODE_MATRIX_MODE,
  372.     NODE_MULT_MATRIX,
  373.         NODE_NORMAL,
  374.     NODE_PASSTHROUGH,
  375.     NODE_PIXEL_MAP,
  376.     NODE_PIXEL_TRANSFER,
  377.     NODE_PIXEL_ZOOM,
  378.     NODE_POINTSIZE,
  379.     NODE_POLYGON_MODE,
  380.     NODE_POLYGON_OFFSET,
  381.     NODE_POP_ATTRIB,
  382.     NODE_POP_MATRIX,
  383.     NODE_POP_NAME,
  384.     NODE_PUSH_ATTRIB,
  385.     NODE_PUSH_MATRIX,
  386.     NODE_PUSH_NAME,
  387.     NODE_RASTER_POS,
  388.     NODE_READ_BUFFER,
  389.         NODE_SCALE,
  390.     NODE_SCISSOR,
  391.     NODE_SHADE_MODEL,
  392.     NODE_STENCIL_FUNC,
  393.     NODE_STENCIL_MASK,
  394.     NODE_STENCIL_OP,
  395.     NODE_TEXCOORD,
  396.         NODE_TEXENV,
  397.         NODE_TEXGEN,
  398.         NODE_TEXPARAMETER,
  399.     NODE_TEXIMAGE1D,
  400.     NODE_TEXIMAGE2D,
  401.         NODE_TRANSLATE,
  402.         NODE_VERTEX,
  403.     NODE_VIEWPORT,
  404.     NODE_WINDOW_POS,
  405.     /* The following two are meta nodes */
  406.     NODE_CONTINUE,
  407.     NODE_END_OF_LIST
  408. } Kind;
  409.  
  410.  
  411. /*
  412.  * Each command in the display list is stored as a sequence of adjacent
  413.  * nodes in memory.  Each node is the union of a variety of datatypes.
  414.  */
  415. typedef union node {
  416.     Kind        kind;
  417.     GLboolean    b;
  418.     GLbitfield    bf;
  419.     GLshort        s;
  420.     GLushort    us;
  421.     GLint        i;
  422.     GLuint        ui;
  423.     GLenum        e;
  424.     GLfloat        f;
  425.     GLvoid        *data;
  426.     void        *next;    /* If prev node's kind==NODE_CONTINUE */
  427. } Node;
  428.  
  429.  
  430.  
  431. /* Number of nodes of storage needed for each command: */
  432. static GLuint NodeSize[ NODE_CONTINUE ];
  433.  
  434.  
  435. /* Used while a display list is under construction: */
  436. static Node *CurrentListPtr;    /* Head of list being compiled */
  437. static GLuint CurrentListNum;    /* Number of the list being compiled */
  438. static Node *CurrentBlock;    /* Pointer to current block of nodes */
  439. static GLuint CurrentPos;    /* Index into current block of nodes */
  440.  
  441.  
  442.  
  443.  
  444. /**********************************************************************/
  445. /*****                           Private                          *****/
  446. /**********************************************************************/
  447.  
  448.  
  449. /*
  450.  * Return a pointer to the first of 'count' empty nodes.
  451.  */
  452. static Node *alloc_nodes( GLuint count )
  453. {
  454.    Node *n;
  455.  
  456.    if (CurrentPos + count + 2 > BLOCK_SIZE) {
  457.       /* This block is full */
  458.       n = CurrentBlock + CurrentPos;
  459.       n[0].kind = NODE_CONTINUE;
  460.       n[1].next = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
  461.       /* TODO: check for out of memory */
  462.       CurrentBlock = (Node *) n[1].next;
  463.       CurrentPos = 0;
  464.    }
  465.  
  466.    n = CurrentBlock + CurrentPos;
  467.    CurrentPos += count;
  468.    return n;
  469. }
  470.  
  471.  
  472.  
  473. /*
  474.  * Make an empty display list.  This is used by glGenLists() to
  475.  * reserver display list IDs.
  476.  */
  477. static Node *make_empty_list( void )
  478. {
  479.    Node *n = (Node *) malloc( sizeof(Node) );
  480.    n[0].kind = NODE_END_OF_LIST;
  481.    return n;
  482. }
  483.  
  484.  
  485.  
  486. /*
  487.  * Destroy all nodes in a display list.
  488.  * Input:  list - list number in [0..]
  489.  */
  490. void destroy_list( GLuint list )
  491. {
  492.    Node *n, *block;
  493.    GLboolean done;
  494.  
  495.    block = n = CC.ListGroup->List[list];
  496.  
  497.    done = GL_FALSE;
  498.    while (!done) {
  499.       switch (n[0].kind) {
  500.      /* special cases first */
  501.      case NODE_MAP1:
  502.         gl_free_control_points( n[1].e, (GLfloat *) n[6].data );
  503.         n += NodeSize[n[0].kind];
  504.         break;
  505.      case NODE_MAP2:
  506.         gl_free_control_points( n[1].e, (GLfloat *) n[10].data );
  507.         n += NodeSize[n[0].kind];
  508.         break;
  509.      case NODE_DRAW_PIXELS:
  510.         free( n[5].data );
  511.         n += NodeSize[n[0].kind];
  512.         break;
  513.      case NODE_BITMAP:
  514.         free( n[7].data );
  515.         n += NodeSize[n[0].kind];
  516.         break;
  517.      case NODE_TEXIMAGE1D:
  518.         {
  519.            GLint level = n[1].i;
  520.            if (CC.TextureImage1D[level]==n[5].data) {
  521.           /* this texture is currently in use, mark as deletable */
  522.           CC.TextureImage1DDeleteFlag[level] = GL_TRUE;
  523.            }
  524.            else {
  525.           /* this texture is not currently in use, delete it */
  526.           free( n[5].data );
  527.            }
  528.            n += NodeSize[n[0].kind];
  529.         }
  530.         break;
  531.      case NODE_TEXIMAGE2D:
  532.         {
  533.            GLint level = n[1].i;
  534.            if (CC.TextureImage2D[level]==n[6].data) {
  535.           /* this texture is currently in use, mark as deletable */
  536.           CC.TextureImage2DDeleteFlag[level] = GL_TRUE;
  537.            }
  538.            else {
  539.           /* this texture is not currently in use, delete it */
  540.           free( n[6].data );
  541.            }
  542.            n += NodeSize[n[0].kind];
  543.         }
  544.         break;
  545.      case NODE_CONTINUE:
  546.         n = (Node *) n[1].next;
  547.         free( block );
  548.         block = n;
  549.         break;
  550.      case NODE_END_OF_LIST:
  551.         free( block );
  552.         done = GL_TRUE;
  553.         break;
  554.      default:
  555.         /* Most frequent case */
  556.         n += NodeSize[n[0].kind];
  557.         break;
  558.       }
  559.    }
  560.  
  561.    CC.ListGroup->List[list] = NULL;
  562. }
  563.  
  564.  
  565.  
  566. /*
  567.  * Translate the nth element of list from type to GLuint.
  568.  */
  569. static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list )
  570. {
  571.    GLbyte *bptr;
  572.    GLubyte *ubptr;
  573.    GLshort *sptr;
  574.    GLushort *usptr;
  575.    GLint *iptr;
  576.    GLuint *uiptr;
  577.    GLfloat *fptr;
  578.  
  579.    switch (type) {
  580.       case GL_BYTE:
  581.          bptr = (GLbyte *) list;
  582.          return (GLuint) *(bptr+n);
  583.       case GL_UNSIGNED_BYTE:
  584.          ubptr = (GLubyte *) list;
  585.          return (GLuint) *(ubptr+n);
  586.       case GL_SHORT:
  587.          sptr = (GLshort *) list;
  588.          return (GLuint) *(sptr+n);
  589.       case GL_UNSIGNED_SHORT:
  590.          usptr = (GLushort *) list;
  591.          return (GLuint) *(usptr+n);
  592.       case GL_INT:
  593.          iptr = (GLint *) list;
  594.          return (GLuint) *(iptr+n);
  595.       case GL_UNSIGNED_INT:
  596.          uiptr = (GLuint *) list;
  597.          return (GLuint) *(uiptr+n);
  598.       case GL_FLOAT:
  599.          fptr = (GLfloat *) list;
  600.          return (GLuint) *(fptr+n);
  601.       case GL_2_BYTES:
  602.          ubptr = ((GLubyte *) list) + 2*n;
  603.          return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
  604.       case GL_3_BYTES:
  605.          ubptr = ((GLubyte *) list) + 3*n;
  606.          return (GLuint) *ubptr * 65536
  607.               + (GLuint) *(ubptr+1) * 256
  608.               + (GLuint) *(ubptr+2);
  609.       case GL_4_BYTES:
  610.          ubptr = ((GLubyte *) list) + 4*n;
  611.          return (GLuint) *ubptr * 16777216
  612.               + (GLuint) *(ubptr+1) * 65536
  613.               + (GLuint) *(ubptr+2) * 256
  614.               + (GLuint) *(ubptr+3);
  615.       default:
  616.          return 0;
  617.    }
  618. }
  619.  
  620.  
  621.  
  622.  
  623. /**********************************************************************/
  624. /*****                        Public                              *****/
  625. /**********************************************************************/
  626.  
  627. void gl_init_lists( void )
  628. {
  629.    static int init_flag = 0;
  630.  
  631.    if (init_flag==0) {
  632.       CurrentListPtr = CurrentBlock = NULL;
  633.       CurrentListNum = 0;
  634.  
  635.       NodeSize[NODE_ACCUM] = 3;
  636.       NodeSize[NODE_ALPHA_FUNC] = 3;
  637.       NodeSize[NODE_BEGIN] = 2;
  638.       NodeSize[NODE_BITMAP] = 8;
  639.       NodeSize[NODE_BLEND_COLOR] = 5;
  640.       NodeSize[NODE_BLEND_EQUATION] = 2;
  641.       NodeSize[NODE_BLEND_FUNC] = 3;
  642.       NodeSize[NODE_CALL_LIST] = 2;
  643.       NodeSize[NODE_CALL_LIST_OFFSET] = 2;
  644.       NodeSize[NODE_CLEAR] = 2;
  645.       NodeSize[NODE_CLEAR_ACCUM] = 5;
  646.       NodeSize[NODE_CLEAR_COLOR] = 5;
  647.       NodeSize[NODE_CLEAR_DEPTH] = 2;
  648.       NodeSize[NODE_CLEAR_INDEX] = 2;
  649.       NodeSize[NODE_CLEAR_STENCIL] = 2;
  650.       NodeSize[NODE_CLIP_PLANE] = 6;
  651.       NodeSize[NODE_COLOR] = 5;
  652.       NodeSize[NODE_COLOR_MASK] = 5;
  653.       NodeSize[NODE_COLOR_MATERIAL] = 3;
  654.       NodeSize[NODE_COPY_PIXELS] = 6;
  655.       NodeSize[NODE_CULL_FACE] = 2;
  656.       NodeSize[NODE_DEPTH_FUNC] = 2;
  657.       NodeSize[NODE_DEPTH_MASK] = 2;
  658.       NodeSize[NODE_DEPTH_RANGE] = 3;
  659.       NodeSize[NODE_DISABLE] = 2;
  660.       NodeSize[NODE_DRAW_BUFFER] = 2;
  661.       NodeSize[NODE_DRAW_PIXELS] = 6;
  662.       NodeSize[NODE_ENABLE] = 2;
  663.       NodeSize[NODE_EDGE_FLAG] = 2;
  664.       NodeSize[NODE_END] = 1;
  665.       NodeSize[NODE_EVALCOORD1] = 2;
  666.       NodeSize[NODE_EVALCOORD2] = 3;
  667.       NodeSize[NODE_EVALMESH1] = 4;
  668.       NodeSize[NODE_EVALMESH2] = 6;
  669.       NodeSize[NODE_EVALPOINT1] = 2;
  670.       NodeSize[NODE_EVALPOINT2] = 3;
  671.       NodeSize[NODE_FOG] = 6;
  672.       NodeSize[NODE_FRONT_FACE] = 2;
  673.       NodeSize[NODE_HINT] = 3;
  674.       NodeSize[NODE_INDEX] = 2;
  675.       NodeSize[NODE_INDEX_MASK] = 2;
  676.       NodeSize[NODE_INIT_NAMES] = 1;
  677.       NodeSize[NODE_LIGHT] = 7;
  678.       NodeSize[NODE_LIGHT_MODEL] = 6;
  679.       NodeSize[NODE_LINE_STIPPLE] = 3;
  680.       NodeSize[NODE_LINE_WIDTH] = 2;
  681.       NodeSize[NODE_LIST_BASE] = 2;
  682.       NodeSize[NODE_LOAD_MATRIX] = 17;
  683.       NodeSize[NODE_LOAD_NAME] = 2;
  684.       NodeSize[NODE_LOGIC_OP] = 2;
  685.       NodeSize[NODE_MAP1] = 7;
  686.       NodeSize[NODE_MAP2] = 11;
  687.       NodeSize[NODE_MAPGRID1] = 4;
  688.       NodeSize[NODE_MAPGRID2] = 7;
  689.       NodeSize[NODE_MATERIAL] = 7;
  690.       NodeSize[NODE_MATRIX_MODE] = 2;
  691.       NodeSize[NODE_MULT_MATRIX] = 17;
  692.       NodeSize[NODE_NORMAL] = 4;
  693.       NodeSize[NODE_PASSTHROUGH] = 2;
  694.       NodeSize[NODE_PIXEL_MAP] = 4;
  695.       NodeSize[NODE_PIXEL_TRANSFER] = 3;
  696.       NodeSize[NODE_PIXEL_ZOOM] = 3;
  697.       NodeSize[NODE_POINTSIZE] = 2;
  698.       NodeSize[NODE_POLYGON_MODE] = 3;
  699.       NodeSize[NODE_POLYGON_OFFSET] = 3;
  700.       NodeSize[NODE_POP_ATTRIB] = 1;
  701.       NodeSize[NODE_POP_MATRIX] = 1;
  702.       NodeSize[NODE_POP_NAME] = 1;
  703.       NodeSize[NODE_PUSH_ATTRIB] = 2;
  704.       NodeSize[NODE_PUSH_MATRIX] = 1;
  705.       NodeSize[NODE_PUSH_NAME] = 2;
  706.       NodeSize[NODE_RASTER_POS] = 5;
  707.       NodeSize[NODE_READ_BUFFER] = 2;
  708.       NodeSize[NODE_SCALE] = 4;
  709.       NodeSize[NODE_SCISSOR] = 5;
  710.       NodeSize[NODE_STENCIL_FUNC] = 4;
  711.       NodeSize[NODE_STENCIL_MASK] = 2;
  712.       NodeSize[NODE_STENCIL_OP] = 4;
  713.       NodeSize[NODE_SHADE_MODEL] = 2;
  714.       NodeSize[NODE_TEXCOORD] = 5;
  715.       NodeSize[NODE_TEXENV] = 7;
  716.       NodeSize[NODE_TEXGEN] = 7;
  717.       NodeSize[NODE_TEXPARAMETER] = 7;
  718.       NodeSize[NODE_TEXIMAGE1D] = 6;
  719.       NodeSize[NODE_TEXIMAGE2D] = 7;
  720.       NodeSize[NODE_TRANSLATE] = 4;
  721.       NodeSize[NODE_VERTEX] = 5;
  722.       NodeSize[NODE_VIEWPORT] = 5;
  723.       NodeSize[NODE_WINDOW_POS] = 5;
  724.    }
  725.    init_flag = 1;
  726. }
  727.  
  728.  
  729.  
  730. /*
  731.  * Return the name of the display list currently being compiled.  This
  732.  * function is only called by glGet().
  733.  */
  734. GLint gl_list_index( void )
  735. {
  736.    return CurrentListNum;
  737. }
  738.  
  739.  
  740.  
  741. /*
  742.  * Display List compilation functions
  743.  */
  744.  
  745.  
  746. void gl_save_accum( GLenum op, GLfloat value )
  747. {
  748.    Node *n = alloc_nodes(3);
  749.    if (n) {
  750.       n[0].kind = NODE_ACCUM;
  751.       n[1].e = op;
  752.       n[2].f = value;
  753.    }
  754. }
  755.  
  756.  
  757. void gl_save_alphafunc( GLenum func, GLclampf ref )
  758. {
  759.    Node *n = alloc_nodes(3);
  760.    if (n) {
  761.       n[0].kind = NODE_ALPHA_FUNC;
  762.       n[1].e = func;
  763.       n[2].f = (GLfloat) ref;
  764.    }
  765. }
  766.  
  767.  
  768. /*
  769.  * Compile a glBegin into current display list.
  770.  */
  771. void gl_save_begin( GLenum mode )
  772. {
  773.    Node *n = alloc_nodes(2);
  774.    if (n) {
  775.       n[0].kind = NODE_BEGIN;
  776.       n[1].e = mode;
  777.    }
  778. }
  779.  
  780.  
  781. void gl_save_bitmap( GLsizei width, GLsizei height,
  782.              GLfloat xorig, GLfloat yorig,
  783.              GLfloat xmove, GLfloat ymove,
  784.              const GLubyte *bitmap )
  785. {
  786.    Node *n = alloc_nodes(8);
  787.    if (n) {
  788.       n[0].kind = NODE_BITMAP;
  789.       n[1].i = (GLint) width;
  790.       n[2].i = (GLint) height;
  791.       n[3].f = xorig;
  792.       n[4].f = yorig;
  793.       n[5].f = xmove;
  794.       n[6].f = ymove;
  795.       n[7].data = (void *) bitmap;
  796.    }
  797. }
  798.  
  799.  
  800. void gl_save_blendequation( GLenum mode )
  801. {
  802.    Node *n = alloc_nodes(2);
  803.    if (n) {
  804.       n[0].kind = NODE_BLEND_EQUATION;
  805.       n[1].e = mode;
  806.    }
  807. }
  808.  
  809.  
  810. void gl_save_blendfunc( GLenum sfactor, GLenum dfactor )
  811. {
  812.    Node *n = alloc_nodes(3);
  813.    if (n) {
  814.       n[0].kind = NODE_BLEND_FUNC;
  815.       n[1].e = sfactor;
  816.       n[2].e = dfactor;
  817.    }
  818. }
  819.  
  820.  
  821. void gl_save_blendcolor( GLfloat red, GLfloat green,
  822.                          GLfloat blue, GLfloat alpha )
  823. {
  824.    Node *n = alloc_nodes(5);
  825.    if (n) {
  826.       n[0].kind = NODE_BLEND_COLOR;
  827.       n[1].f = red;
  828.       n[2].f = green;
  829.       n[3].f = blue;
  830.       n[4].f = alpha;
  831.    }
  832. }
  833.  
  834.  
  835. void gl_save_clear( GLbitfield mask )
  836. {
  837.    Node *n = alloc_nodes(2);
  838.    if (n) {
  839.       n[0].kind = NODE_CLEAR;
  840.       n[1].bf = mask;
  841.    }
  842. }
  843.  
  844.  
  845. void gl_save_clearaccum( GLfloat red, GLfloat green,
  846.              GLfloat blue, GLfloat alpha )
  847. {
  848.    Node *n = alloc_nodes(5);
  849.    if (n) {
  850.       n[0].kind = NODE_CLEAR_ACCUM;
  851.       n[1].f = red;
  852.       n[2].f = green;
  853.       n[3].f = blue;
  854.       n[4].f = alpha;
  855.    }
  856. }
  857.  
  858.  
  859. void gl_save_clearcolor( GLclampf red, GLclampf green,
  860.              GLclampf blue, GLclampf alpha )
  861. {
  862.    Node *n = alloc_nodes(5);
  863.    if (n) {
  864.       n[0].kind = NODE_CLEAR_COLOR;
  865.       n[1].f = red;
  866.       n[2].f = green;
  867.       n[3].f = blue;
  868.       n[4].f = alpha;
  869.    }
  870. }
  871.  
  872.  
  873. void gl_save_cleardepth( GLclampd depth )
  874. {
  875.    Node *n = alloc_nodes(2);
  876.    if (n) {
  877.       n[0].kind = NODE_CLEAR_DEPTH;
  878.       n[1].f = (GLfloat) depth;
  879.    }
  880. }
  881.  
  882.  
  883. void gl_save_clearindex( GLfloat c )
  884. {
  885.    Node *n = alloc_nodes(2);
  886.    if (n) {
  887.       n[0].kind = NODE_CLEAR_INDEX;
  888.       n[1].f = c;
  889.    }
  890. }
  891.  
  892.  
  893. void gl_save_clearstencil( GLint s )
  894. {
  895.    Node *n = alloc_nodes(2);
  896.    if (n) {
  897.       n[0].kind = NODE_CLEAR_STENCIL;
  898.       n[1].i = s;
  899.    }
  900. }
  901.  
  902.  
  903. void gl_save_clipplane( GLenum plane, const GLfloat *equ )
  904. {
  905.    Node *n = alloc_nodes(6);
  906.    if (n) {
  907.       n[0].kind = NODE_CLIP_PLANE;
  908.       n[1].e = plane;
  909.       n[2].f = equ[0];
  910.       n[3].f = equ[1];
  911.       n[4].f = equ[2];
  912.       n[5].f = equ[3];
  913.    }
  914. }
  915.  
  916.  
  917.  
  918. /*
  919.  * Add a color to current display list.
  920.  */
  921. void gl_save_color( const GLint c[4] )
  922. {
  923.    Node *n = alloc_nodes(5);
  924.    if (n) {
  925.       n[0].kind = NODE_COLOR;
  926.       n[1].i = c[0];
  927.       n[2].i = c[1];
  928.       n[3].i = c[2];
  929.       n[4].i = c[3];
  930.    }
  931. }
  932.  
  933.  
  934. void gl_save_colormask( GLboolean red, GLboolean green,
  935.              GLboolean blue, GLboolean alpha )
  936. {
  937.    Node *n = alloc_nodes(5);
  938.    if (n) {
  939.       n[0].kind = NODE_COLOR_MASK;
  940.       n[1].b = red;
  941.       n[2].b = green;
  942.       n[3].b = blue;
  943.       n[4].b = alpha;
  944.    }
  945. }
  946.  
  947.  
  948. void gl_save_colormaterial( GLenum face, GLenum mode )
  949. {
  950.    Node *n = alloc_nodes(3);
  951.    if (n) {
  952.       n[0].kind = NODE_COLOR_MATERIAL;
  953.       n[1].e = face;
  954.       n[2].e = mode;
  955.    }
  956. }
  957.  
  958.  
  959. void gl_save_copypixels( GLint x, GLint y,
  960.              GLsizei width, GLsizei height, GLenum type )
  961. {
  962.    Node *n = alloc_nodes(6);
  963.    if (n) {
  964.       n[0].kind = NODE_COPY_PIXELS;
  965.       n[1].i = x;
  966.       n[2].i = y;
  967.       n[3].i = (GLint) width;
  968.       n[4].i = (GLint) height;
  969.       n[5].e = type;
  970.    }
  971.  
  972. }
  973.  
  974.  
  975.  
  976. void gl_save_cullface( GLenum mode )
  977. {
  978.    Node *n = alloc_nodes(2);
  979.    if (n) {
  980.       n[0].kind = NODE_CULL_FACE;
  981.       n[1].e = mode;
  982.    }
  983. }
  984.  
  985.  
  986. void gl_save_depthfunc( GLenum func )
  987. {
  988.    Node *n = alloc_nodes(2);
  989.    if (n) {
  990.       n[0].kind = NODE_DEPTH_FUNC;
  991.       n[1].e = func;
  992.    }
  993. }
  994.  
  995.  
  996. void gl_save_depthmask( GLboolean mask )
  997. {
  998.    Node *n = alloc_nodes(2);
  999.    if (n) {
  1000.       n[0].kind = NODE_DEPTH_MASK;
  1001.       n[1].b = mask;
  1002.    }
  1003. }
  1004.  
  1005.  
  1006. void gl_save_depthrange( GLclampd nearval, GLclampd farval )
  1007. {
  1008.    Node *n = alloc_nodes(3);
  1009.    if (n) {
  1010.       n[0].kind = NODE_DEPTH_RANGE;
  1011.       n[1].f = (GLfloat) nearval;
  1012.       n[2].f = (GLfloat) farval;
  1013.    }
  1014. }
  1015.  
  1016.  
  1017. void gl_save_disable( GLenum cap )
  1018. {
  1019.    Node *n = alloc_nodes(2);
  1020.    if (n) {
  1021.       n[0].kind = NODE_DISABLE;
  1022.       n[1].e = cap;
  1023.    }
  1024. }
  1025.  
  1026.  
  1027. void gl_save_drawbuffer( GLenum mode )
  1028. {
  1029.    Node *n = alloc_nodes(2);
  1030.    if (n) {
  1031.       n[0].kind = NODE_DRAW_BUFFER;
  1032.       n[1].e = mode;
  1033.    }
  1034. }
  1035.  
  1036.  
  1037. void gl_save_drawpixels( GLsizei width, GLsizei height, GLenum format,
  1038.              GLenum type, GLvoid *pixels )
  1039. {
  1040.    Node *n = alloc_nodes(6);
  1041.    if (n) {
  1042.       n[0].kind = NODE_DRAW_PIXELS;
  1043.       n[1].i = (GLint) width;
  1044.       n[2].i = (GLint) height;
  1045.       n[3].e = format;
  1046.       n[4].e = type;
  1047.       n[5].data = pixels;
  1048.    }
  1049. }
  1050.  
  1051.  
  1052. void gl_save_edgeflag( GLboolean flag )
  1053. {
  1054.    Node *n = alloc_nodes(2);
  1055.    if (n) {
  1056.       n[0].kind = NODE_EDGE_FLAG;
  1057.       n[1].b = flag;
  1058.    }
  1059. }
  1060.  
  1061.  
  1062. void gl_save_enable( GLenum cap )
  1063. {
  1064.    Node *n = alloc_nodes(2);
  1065.    if (n) {
  1066.       n[0].kind = NODE_ENABLE;
  1067.       n[1].e = cap;
  1068.    }
  1069. }
  1070.  
  1071.  
  1072. /*
  1073.  * Compile a glEnd into current display list.
  1074.  */
  1075. void gl_save_end( void )
  1076. {
  1077.    Node *n = alloc_nodes(1);
  1078.    if (n) {
  1079.       n[0].kind = NODE_END;
  1080.    }
  1081. }
  1082.  
  1083.  
  1084.  
  1085. void gl_save_evalcoord1( GLfloat u )
  1086. {
  1087.    Node *n = alloc_nodes(2);
  1088.    if (n) {
  1089.       n[0].kind = NODE_EVALCOORD1;
  1090.       n[1].f = u;
  1091.    }
  1092. }
  1093.  
  1094.  
  1095. void gl_save_evalcoord2( GLfloat u, GLfloat v )
  1096. {
  1097.    Node *n = alloc_nodes(3);
  1098.    if (n) {
  1099.       n[0].kind = NODE_EVALCOORD2;
  1100.       n[1].f = u;
  1101.       n[2].f = v;
  1102.    }
  1103. }
  1104.  
  1105.  
  1106.  
  1107. void gl_save_evalmesh1( GLenum mode, GLint i1, GLint i2 )
  1108. {
  1109.    Node *n = alloc_nodes(4);
  1110.    if (n) {
  1111.       n[0].kind = NODE_EVALMESH1;
  1112.       n[1].e = mode;
  1113.       n[2].i = i1;
  1114.       n[3].i = i2;
  1115.    }
  1116. }
  1117.  
  1118.  
  1119.  
  1120. void gl_save_evalmesh2( GLenum mode, GLint i1, GLint i2,
  1121.                 GLint j1, GLint j2 )
  1122. {
  1123.    Node *n = alloc_nodes(6);
  1124.    if (n) {
  1125.       n[0].kind = NODE_EVALMESH2;
  1126.       n[1].e = mode;
  1127.       n[2].i = i1;
  1128.       n[3].i = i2;
  1129.       n[4].i = j1;
  1130.       n[5].i = j2;
  1131.    }
  1132. }
  1133.  
  1134.  
  1135. void gl_save_evalpoint1( GLint i )
  1136. {
  1137.    Node *n = alloc_nodes(2);
  1138.    if (n) {
  1139.       n[0].kind = NODE_EVALPOINT1;
  1140.       n[1].i = i;
  1141.    }
  1142. }
  1143.  
  1144.  
  1145. void gl_save_evalpoint2( GLint i, GLint j )
  1146. {
  1147.    Node *n = alloc_nodes(3);
  1148.    if (n) {
  1149.       n[0].kind = NODE_EVALPOINT2;
  1150.       n[1].i = i;
  1151.       n[2].i = j;
  1152.    }
  1153. }
  1154.  
  1155.  
  1156. void gl_save_fog( GLenum pname, const GLfloat *params )
  1157. {
  1158.    Node *n = alloc_nodes(6);
  1159.    if (n) {
  1160.       n[0].kind = NODE_FOG;
  1161.       n[1].e = pname;
  1162.       n[2].f = params[0];
  1163.       n[3].f = params[1];
  1164.       n[4].f = params[2];
  1165.       n[5].f = params[3];
  1166.    }
  1167. }
  1168.  
  1169.  
  1170. void gl_save_frontface( GLenum mode )
  1171. {
  1172.    Node *n = alloc_nodes(2);
  1173.    if (n) {
  1174.       n[0].kind = NODE_FRONT_FACE;
  1175.       n[1].e = mode;
  1176.    }
  1177. }
  1178.  
  1179.  
  1180. void gl_save_hint( GLenum target, GLenum mode )
  1181. {
  1182.    Node *n = alloc_nodes(3);
  1183.    if (n) {
  1184.       n[0].kind = NODE_HINT;
  1185.       n[1].e = target;
  1186.       n[2].e = mode;
  1187.    }
  1188. }
  1189.  
  1190.  
  1191. /*
  1192.  * Compile a glIndex call into current display list.
  1193.  */
  1194. void gl_save_index( GLuint index )
  1195. {
  1196.    Node *n = alloc_nodes(2);
  1197.    if (n) {
  1198.       n[0].kind = NODE_INDEX;
  1199.       n[1].ui = index;
  1200.    }
  1201. }
  1202.  
  1203.  
  1204. void gl_save_indexmask( GLuint mask )
  1205. {
  1206.    Node *n = alloc_nodes(2);
  1207.    if (n) {
  1208.       n[0].kind = NODE_INDEX_MASK;
  1209.       n[1].ui = mask;
  1210.    }
  1211. }
  1212.  
  1213.  
  1214.  
  1215. void gl_save_initnames( void )
  1216. {
  1217.    Node *n = alloc_nodes(1);
  1218.    if (n) {
  1219.       n[0].kind = NODE_INIT_NAMES;
  1220.    }
  1221. }
  1222.  
  1223.       
  1224. /*
  1225.  * save a glLight* call.
  1226.  */
  1227. void gl_save_light( GLenum light, GLenum pname, const GLfloat *params,
  1228.             GLuint numparams )
  1229. {
  1230.    Node *n = alloc_nodes(7);
  1231.    if (n) {
  1232.       GLuint i;
  1233.       n[0].kind = NODE_LIGHT;
  1234.       n[1].e = light;
  1235.       n[2].e = pname;
  1236.       for (i=0;i<numparams;i++) {
  1237.      n[3+i].f = params[i];
  1238.       }
  1239.    }
  1240. }
  1241.  
  1242.  
  1243. void gl_save_lightmodel( GLenum pname, const GLfloat *params )
  1244. {
  1245.    Node *n = alloc_nodes(6);
  1246.    if (n) {
  1247.       n[0].kind = NODE_LIGHT_MODEL;
  1248.       n[1].e = pname;
  1249.       n[2].f = params[0];
  1250.       n[3].f = params[1];
  1251.       n[4].f = params[2];
  1252.       n[5].f = params[3];
  1253.    }
  1254. }
  1255.  
  1256.  
  1257.  
  1258. /*
  1259.  * Save a glLineStipple call.
  1260.  */
  1261. void gl_save_linestipple( GLint factor, GLushort pattern )
  1262. {
  1263.    Node *n = alloc_nodes(3);
  1264.    if (n) {
  1265.       n[0].kind = NODE_LINE_STIPPLE;
  1266.       n[1].i = factor;
  1267.       n[2].us = pattern;
  1268.    }
  1269. }
  1270.  
  1271.  
  1272. /*
  1273.  * Save a glLineWidth call.
  1274.  */
  1275. void gl_save_linewidth( GLfloat width )
  1276. {
  1277.    Node *n = alloc_nodes(2);
  1278.    if (n) {
  1279.       n[0].kind = NODE_LINE_WIDTH;
  1280.       n[1].f = width;
  1281.    }
  1282. }
  1283.  
  1284.  
  1285. /*
  1286.  * Save a glListBase call.
  1287.  */
  1288. void gl_save_listbase( GLuint base )
  1289. {
  1290.    Node *n = alloc_nodes(2);
  1291.    if (n) {
  1292.       n[0].kind = NODE_LIST_BASE;
  1293.       n[1].ui = base;
  1294.    }
  1295. }
  1296.  
  1297.  
  1298. /*
  1299.  * Add a load matrix operation to current display list.
  1300.  */
  1301. void gl_save_loadmatrix( const GLfloat *m )
  1302. {
  1303.    Node *n = alloc_nodes(17);
  1304.    if (n) {
  1305.       GLuint i;
  1306.       n[0].kind = NODE_LOAD_MATRIX;
  1307.       for (i=0;i<16;i++) {
  1308.      n[1+i].f = m[i];
  1309.       }
  1310.    }
  1311. }
  1312.  
  1313.  
  1314. /*
  1315.  * Add a glLoadName to the current display list.
  1316.  */
  1317. void gl_save_loadname( GLuint name )
  1318. {
  1319.    Node *n = alloc_nodes(2);
  1320.    if (n) {
  1321.       n[0].kind = NODE_LOAD_NAME;
  1322.       n[1].ui = name;
  1323.    }
  1324. }
  1325.  
  1326.  
  1327. /*
  1328.  * Save a glLogicOp call.
  1329.  */
  1330. void gl_save_logicop( GLenum opcode )
  1331. {
  1332.    Node *n = alloc_nodes(2);
  1333.    if (n) {
  1334.       n[0].kind = NODE_LOGIC_OP;
  1335.       n[1].e = opcode;
  1336.    }
  1337. }
  1338.  
  1339.  
  1340.  
  1341. void gl_save_map1( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1342.            GLint order, const GLfloat *points )
  1343. {
  1344.    Node *n = alloc_nodes(7);
  1345.    if (n) {
  1346.       n[0].kind = NODE_MAP1;
  1347.       n[1].e = target;
  1348.       n[2].f = u1;
  1349.       n[3].f = u2;
  1350.       n[4].i = stride;
  1351.       n[5].i = order;
  1352.       n[6].data = (void *) points;
  1353.    }
  1354. }
  1355.  
  1356.  
  1357.  
  1358. void gl_save_map2( GLenum target,
  1359.            GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1360.            GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1361.            const GLfloat *points )
  1362. {
  1363.    Node *n = alloc_nodes(11);
  1364.    if (n) {
  1365.       n[0].kind = NODE_MAP2;
  1366.       n[1].e = target;
  1367.       n[2].f = u1;
  1368.       n[3].f = u2;
  1369.       n[4].f = v1;
  1370.       n[5].f = v2;
  1371.       n[6].i = ustride;
  1372.       n[7].i = vstride;
  1373.       n[8].i = uorder;
  1374.       n[9].i = vorder;
  1375.       n[10].data = (void *) points;
  1376.    }
  1377. }
  1378.  
  1379.  
  1380.  
  1381. void gl_save_mapgrid1( GLint un, GLfloat u1, GLfloat u2 )
  1382. {
  1383.    Node *n = alloc_nodes(4);
  1384.    if (n) {
  1385.       n[0].kind = NODE_MAPGRID1;
  1386.       n[1].i = un;
  1387.       n[2].f = u1;
  1388.       n[3].f = u2;
  1389.    }
  1390. }
  1391.  
  1392.  
  1393. void gl_save_mapgrid2( GLint un, GLfloat u1, GLfloat u2,
  1394.                GLint vn, GLfloat v1, GLfloat v2 )
  1395. {
  1396.    Node *n = alloc_nodes(7);
  1397.    if (n) {
  1398.       n[0].kind = NODE_MAPGRID2;
  1399.       n[1].i = un;
  1400.       n[2].f = u1;
  1401.       n[3].f = u2;
  1402.       n[4].i = vn;
  1403.       n[5].f = v1;
  1404.       n[6].f = v2;
  1405.    }
  1406. }
  1407.  
  1408.  
  1409.  
  1410. /*
  1411.  * Add a glMaterial call to current display list.
  1412.  */
  1413. void gl_save_material( GLenum face, GLenum pname, const GLfloat *params )
  1414. {
  1415.    Node *n = alloc_nodes(7);
  1416.    if (n) {
  1417.       n[0].kind = NODE_MATERIAL;
  1418.       n[1].e = face;
  1419.       n[2].e = pname;
  1420.       n[3].f = params[0];
  1421.       n[4].f = params[1];
  1422.       n[5].f = params[2];
  1423.       n[6].f = params[3];
  1424.    }
  1425. }
  1426.  
  1427.  
  1428. /*
  1429.  * Add a glMatrixMode call to current display list.
  1430.  */
  1431. void gl_save_matrixmode( GLenum mode )
  1432. {
  1433.    Node *n = alloc_nodes(2);
  1434.    if (n) {
  1435.       n[0].kind = NODE_MATRIX_MODE;
  1436.       n[1].e = mode;
  1437.    }
  1438. }
  1439.  
  1440.  
  1441. /*
  1442.  * Add a mult matrix operation to current display list.
  1443.  */
  1444. void gl_save_multmatrix( const GLfloat *m )
  1445. {
  1446.    Node *n = alloc_nodes(17);
  1447.    if (n) {
  1448.       GLuint i;
  1449.       n[0].kind = NODE_MULT_MATRIX;
  1450.       for (i=0;i<16;i++) {
  1451.      n[1+i].f = m[i];
  1452.       }
  1453.    }
  1454. }
  1455.  
  1456.  
  1457.  
  1458. /*
  1459.  * Add a normal to current display list.
  1460.  */
  1461. void gl_save_normal3fv( const GLfloat norm[3] )
  1462. {
  1463.    Node *n = alloc_nodes(4);
  1464.    if (n) {
  1465.       n[0].kind = NODE_NORMAL;
  1466.       n[1].f = norm[0];
  1467.       n[2].f = norm[1];
  1468.       n[3].f = norm[2];
  1469.    }
  1470. }
  1471.  
  1472.  
  1473.  
  1474. /*
  1475.  * Add a normal to current display list.
  1476.  */
  1477. void gl_save_normal3f( GLfloat nx, GLfloat ny, GLfloat nz )
  1478. {
  1479.    Node *n = alloc_nodes(4);
  1480.    if (n) {
  1481.       n[0].kind = NODE_NORMAL;
  1482.       n[1].f = nx;
  1483.       n[2].f = ny;
  1484.       n[3].f = nz;
  1485.    }
  1486. }
  1487.  
  1488.  
  1489.  
  1490. /*
  1491.  * Save a glPixelMap call.
  1492.  */
  1493. void gl_save_pixelmap( GLenum map, GLint mapsize, const GLfloat *values )
  1494. {
  1495.    Node *n = alloc_nodes(4);
  1496.    if (n) {
  1497.       n[0].kind = NODE_PIXEL_MAP;
  1498.       n[1].e = map;
  1499.       n[2].i = mapsize;
  1500.       n[3].data  = (void *) malloc( mapsize * sizeof(GLfloat) );
  1501.       MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
  1502.    }
  1503. }
  1504.  
  1505.  
  1506.  
  1507. /*
  1508.  * Save a glPixelTransfer call.
  1509.  */
  1510. void gl_save_pixeltransfer( GLenum pname, GLfloat param )
  1511. {
  1512.    Node *n = alloc_nodes(3);
  1513.    if (n) {
  1514.       n[0].kind = NODE_PIXEL_TRANSFER;
  1515.       n[1].e = pname;
  1516.       n[2].f = param;
  1517.    }
  1518. }
  1519.  
  1520.  
  1521.  
  1522. /*
  1523.  * Save a glPixelZoom call.
  1524.  */
  1525. void gl_save_pixelzoom( GLfloat xfactor, GLfloat yfactor )
  1526. {
  1527.    Node *n = alloc_nodes(4);
  1528.    if (n) {
  1529.       n[0].kind = NODE_PIXEL_ZOOM;
  1530.       n[1].f = xfactor;
  1531.       n[2].f = yfactor;
  1532.    }
  1533. }
  1534.  
  1535.  
  1536.  
  1537. /*
  1538.  * Save a glPointSize call.
  1539.  */
  1540. void gl_save_pointsize( GLfloat size )
  1541. {
  1542.    Node *n = alloc_nodes(2);
  1543.    if (n) {
  1544.       n[0].kind = NODE_POINTSIZE;
  1545.       n[1].f = size;
  1546.    }
  1547. }
  1548.  
  1549.  
  1550.  
  1551. /*
  1552.  * Save a glPolygonMode call.
  1553.  */
  1554. void gl_save_polygonmode( GLenum face, GLenum mode )
  1555. {
  1556.    Node *n = alloc_nodes(3);
  1557.    if (n) {
  1558.       n[0].kind = NODE_POLYGON_MODE;
  1559.       n[1].e = face;
  1560.       n[2].e = mode;
  1561.    }
  1562. }
  1563.  
  1564.  
  1565.  
  1566. void gl_save_polygonoffset( GLfloat factor, GLfloat bias )
  1567. {
  1568.    Node *n = alloc_nodes(3);
  1569.    if (n) {
  1570.       n[0].kind = NODE_POLYGON_OFFSET;
  1571.       n[1].f = factor;
  1572.       n[2].f = bias;
  1573.    }
  1574. }
  1575.  
  1576.  
  1577. /*
  1578.  * Add a pop attributies operation to current display list.
  1579.  */
  1580. void gl_save_popattrib( void )
  1581. {
  1582.    Node *n = alloc_nodes(1);
  1583.    if (n) {
  1584.       n[0].kind = NODE_POP_ATTRIB;
  1585.    }
  1586. }
  1587.  
  1588.  
  1589. /*
  1590.  * Add a pop matrix operation to current display list.
  1591.  */
  1592. void gl_save_popmatrix( void )
  1593. {
  1594.    Node *n = alloc_nodes(1);
  1595.    if (n) {
  1596.       n[0].kind = NODE_POP_MATRIX;
  1597.    }
  1598. }
  1599.  
  1600.  
  1601. /*
  1602.  * Add a glPopName to the current display list.
  1603.  */
  1604. void gl_save_popname( void )
  1605. {
  1606.    Node *n = alloc_nodes(1);
  1607.    if (n) {
  1608.       n[0].kind = NODE_POP_NAME;
  1609.    }
  1610. }
  1611.  
  1612.  
  1613.  
  1614. /*
  1615.  * Add a push attributies operation to current display list.
  1616.  */
  1617. void gl_save_pushattrib( GLbitfield mask )
  1618. {
  1619.    Node *n = alloc_nodes(2);
  1620.    if (n) {
  1621.       n[0].kind = NODE_PUSH_ATTRIB;
  1622.       n[1].bf = mask;
  1623.    }
  1624. }
  1625.  
  1626.  
  1627.  
  1628. /*
  1629.  * Add a push matrix operation to current display list.
  1630.  */
  1631. void gl_save_pushmatrix( void )
  1632. {
  1633.    Node *n = alloc_nodes(1);
  1634.    if (n) {
  1635.       n[0].kind = NODE_PUSH_MATRIX;
  1636.    }
  1637. }
  1638.  
  1639.  
  1640. /*
  1641.  * Add a glPushName to the current display list.
  1642.  */
  1643. void gl_save_pushname( GLuint name )
  1644. {
  1645.    Node *n = alloc_nodes(2);
  1646.    if (n) {
  1647.       n[0].kind = NODE_PUSH_NAME;
  1648.       n[1].ui = name;
  1649.    }
  1650. }
  1651.  
  1652.  
  1653. void gl_save_rasterpos( const GLfloat v[4] )
  1654. {
  1655.    Node *n = alloc_nodes(5);
  1656.    if (n) {
  1657.       n[0].kind = NODE_RASTER_POS;
  1658.       n[1].f = v[0];
  1659.       n[2].f = v[1];
  1660.       n[3].f = v[2];
  1661.       n[4].f = v[3];
  1662.    }
  1663. }
  1664.  
  1665.  
  1666.  
  1667. void gl_save_passthrough( GLfloat token )
  1668. {
  1669.    Node *n = alloc_nodes(2);
  1670.    if (n) {
  1671.       n[0].kind = NODE_PASSTHROUGH;
  1672.       n[1].f = token;
  1673.    }
  1674. }
  1675.  
  1676.  
  1677.  
  1678. void gl_save_readbuffer( GLenum mode )
  1679. {
  1680.    Node *n = alloc_nodes(2);
  1681.    if (n) {
  1682.       n[0].kind = NODE_READ_BUFFER;
  1683.       n[1].e = mode;
  1684.    }
  1685. }
  1686.  
  1687.  
  1688. /*
  1689.  * Add a glScale to current display list.
  1690.  */
  1691. void gl_save_scale( GLfloat x, GLfloat y, GLfloat z )
  1692. {
  1693.    Node *n = alloc_nodes( 4 );
  1694.    if (n) {
  1695.       n[0].kind = NODE_SCALE;
  1696.       n[1].f = x;
  1697.       n[2].f = y;
  1698.       n[3].f = z;
  1699.    }
  1700. }
  1701.  
  1702.  
  1703. void gl_save_scissor( GLint x, GLint y, GLsizei width, GLsizei height )
  1704. {
  1705.    Node *n = alloc_nodes(5);
  1706.    if (n) {
  1707.       n[0].kind = NODE_SCISSOR;
  1708.       n[1].i = x;
  1709.       n[2].i = y;
  1710.       n[3].i = width;
  1711.       n[4].i = height;
  1712.    }
  1713. }
  1714.  
  1715.  
  1716.  
  1717. /*
  1718.  * Add a glShadeModel call to current display list.
  1719.  */
  1720. void gl_save_shademodel( GLenum mode )
  1721. {
  1722.    Node *n = alloc_nodes(2);
  1723.    if (n) {
  1724.       n[0].kind = NODE_SHADE_MODEL;
  1725.       n[1].e = mode;
  1726.    }
  1727. }
  1728.  
  1729.  
  1730.  
  1731. void gl_save_stencilfunc( GLenum func, GLint ref, GLuint mask )
  1732. {
  1733.    Node *n = alloc_nodes(4);
  1734.    if (n) {
  1735.       n[0].kind = NODE_STENCIL_FUNC;
  1736.       n[1].e = func;
  1737.       n[2].i = ref;
  1738.       n[3].ui = mask;
  1739.    }
  1740. }
  1741.  
  1742.  
  1743.  
  1744. void gl_save_stencilmask( GLuint mask )
  1745. {
  1746.    Node *n = alloc_nodes(2);
  1747.    if (n) {
  1748.       n[0].kind = NODE_STENCIL_MASK;
  1749.       n[1].ui = mask;
  1750.    }
  1751. }
  1752.  
  1753.  
  1754.  
  1755. void gl_save_stencilop( GLenum fail, GLenum zfail, GLenum zpass )
  1756. {
  1757.    Node *n = alloc_nodes(4);
  1758.    if (n) {
  1759.       n[0].kind = NODE_STENCIL_OP;
  1760.       n[1].e = fail;
  1761.       n[2].e = zfail;
  1762.       n[3].e = zpass;
  1763.    }
  1764. }
  1765.  
  1766.  
  1767.  
  1768.  
  1769. /*
  1770.  * Add a texture coordinate to current display list.
  1771.  */
  1772. void gl_save_texcoord( const GLfloat tc[4] )
  1773. {
  1774.    Node *n = alloc_nodes(5);
  1775.    if (n) {
  1776.       n[0].kind = NODE_TEXCOORD;
  1777.       n[1].f = tc[0];
  1778.       n[2].f = tc[1];
  1779.       n[3].f = tc[2];
  1780.       n[4].f = tc[3];
  1781.    }
  1782. }
  1783.  
  1784.  
  1785.  
  1786. void gl_save_texenv( GLenum target, GLenum pname, const GLfloat *params )
  1787. {
  1788.    Node *n = alloc_nodes(7);
  1789.    if (n) {
  1790.       n[0].kind = NODE_TEXENV;
  1791.       n[1].e = target;
  1792.       n[2].e = pname;
  1793.       n[3].f = params[0];
  1794.       n[4].f = params[1];
  1795.       n[5].f = params[2];
  1796.       n[6].f = params[3];
  1797.    }
  1798. }
  1799.  
  1800.  
  1801. void gl_save_texgen( GLenum coord, GLenum pname, const GLfloat *params )
  1802. {
  1803.    Node *n = alloc_nodes(7);
  1804.    if (n) {
  1805.       n[0].kind = NODE_TEXGEN;
  1806.       n[1].e = coord;
  1807.       n[2].e = pname;
  1808.       n[3].f = params[0];
  1809.       n[4].f = params[1];
  1810.       n[5].f = params[2];
  1811.       n[6].f = params[3];
  1812.    }
  1813. }
  1814.  
  1815.  
  1816. void gl_save_texparameter( GLenum target, GLenum pname, const GLfloat *params )
  1817. {
  1818.    Node *n = alloc_nodes(7);
  1819.    if (n) {
  1820.       n[0].kind = NODE_TEXPARAMETER;
  1821.       n[1].e = target;
  1822.       n[2].e = pname;
  1823.       n[3].f = params[0];
  1824.       n[4].f = params[1];
  1825.       n[5].f = params[2];
  1826.       n[6].f = params[3];
  1827.    }
  1828. }
  1829.  
  1830.  
  1831.  
  1832. /*
  1833.  * Add a glTexImage1D call to current display list.
  1834.  */
  1835. void gl_save_teximage1d( GLint level, GLint components,
  1836.              GLsizei width, GLint border,
  1837.              const GLubyte *pixels )
  1838. {
  1839.    Node *n = alloc_nodes(6);
  1840.    if (n) {
  1841.       n[0].kind = NODE_TEXIMAGE1D;
  1842.       n[1].i = level;
  1843.       n[2].i = components;
  1844.       n[3].i = (GLint) width;
  1845.       n[4].i = border;
  1846.       n[5].data = (GLvoid *) pixels;
  1847.    }
  1848. }
  1849.  
  1850.  
  1851.  
  1852. /*
  1853.  * Add a glTexImage2D call to current display list.
  1854.  */
  1855. void gl_save_teximage2d( GLint level, GLint components,
  1856.              GLsizei width, GLsizei height, GLint border,
  1857.              const GLubyte *pixels )
  1858. {
  1859.    Node *n = alloc_nodes(7);
  1860.    if (n) {
  1861.       n[0].kind = NODE_TEXIMAGE2D;
  1862.       n[1].i = level;
  1863.       n[2].i = components;
  1864.       n[3].i = (GLint) width;
  1865.       n[4].i = (GLint) height;
  1866.       n[5].i = border;
  1867.       n[6].data = (GLvoid *) pixels;
  1868.    }
  1869. }
  1870.  
  1871.  
  1872.  
  1873. /*
  1874.  * Add a glTranslate to current display list.
  1875.  */
  1876. void gl_save_translate( GLfloat x, GLfloat y, GLfloat z )
  1877. {
  1878.    Node *n = alloc_nodes( 4 );
  1879.    if (n) {
  1880.       n[0].kind = NODE_TRANSLATE;
  1881.       n[1].f = x;
  1882.       n[2].f = y;
  1883.       n[3].f = z;
  1884.    }
  1885. }
  1886.  
  1887.  
  1888. /*
  1889.  * Add a vertex to current display list.
  1890.  */
  1891. void gl_save_vertex( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  1892. {
  1893.    Node *n = alloc_nodes( 5 );
  1894.    if (n) {
  1895.       n[0].kind = NODE_VERTEX;
  1896.       n[1].f = x;
  1897.       n[2].f = y;
  1898.       n[3].f = z;
  1899.       n[4].f = w;
  1900.    }
  1901. }
  1902.  
  1903.  
  1904.  
  1905. /*
  1906.  * Add a glViewport call to display list.
  1907.  */
  1908. void gl_save_viewport( GLint x, GLint y, GLsizei width, GLsizei height )
  1909. {
  1910.    Node *n = alloc_nodes( 5 );
  1911.    if (n) {
  1912.       n[0].kind = NODE_VIEWPORT;
  1913.       n[1].i = x;
  1914.       n[2].i = y;
  1915.       n[3].i = (GLint) width;
  1916.       n[4].i = (GLint) height;
  1917.    }
  1918. }
  1919.  
  1920.  
  1921. /*
  1922.  * Add a glWindowPosMESA call to display list.
  1923.  */
  1924. void gl_save_windowpos( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  1925. {
  1926.    Node *n = alloc_nodes( 5 );
  1927.    if (n) {
  1928.       n[0].kind = NODE_WINDOW_POS;
  1929.       n[1].f = x;
  1930.       n[2].f = y;
  1931.       n[3].f = z;
  1932.       n[4].f = w;
  1933.    }
  1934. }
  1935.  
  1936.  
  1937.  
  1938. /*
  1939.  * Compile a glCallList call into current display list.
  1940.  */
  1941. static void gl_save_call( GLuint list )
  1942. {
  1943.    Node *n = alloc_nodes(2);
  1944.    if (n) {
  1945.       n[0].kind = NODE_CALL_LIST;
  1946.       n[1].ui = list;
  1947.    }
  1948. }
  1949.  
  1950.  
  1951.  
  1952. /*
  1953.  * Compile a glCallLists call into current display list.  The difference
  1954.  * between this and the above function is that the ListBase value will
  1955.  * be added to the display list number before executing.
  1956.  */
  1957. static void gl_save_call_offset( GLuint list )
  1958. {
  1959.    Node *n = alloc_nodes(2);
  1960.    if (n) {
  1961.       n[0].kind = NODE_CALL_LIST_OFFSET;
  1962.       n[1].ui = list;
  1963.    }
  1964. }
  1965.  
  1966.  
  1967.  
  1968.  
  1969. /**********************************************************************/
  1970. /*                     Display list execution                         */
  1971. /**********************************************************************/
  1972.  
  1973.  
  1974. /*
  1975.  * Execute a display list.  Note that the ListBase offset must have already
  1976.  * been added before calling this function.  I.e. the list argument is
  1977.  * the absolute list number, not relative to ListBase.
  1978.  * Input:  list - list number in [1..]
  1979.  */
  1980. static void execute_list( GLuint list )
  1981. {
  1982.    Node *n;
  1983.    GLboolean done;
  1984.    Kind k;
  1985.  
  1986.    if (!glIsList(list))
  1987.       return;
  1988.  
  1989.    CC.CallDepth++;
  1990.  
  1991.    n = CC.ListGroup->List[list-1];
  1992.    done = GL_FALSE;
  1993.    while (!done) {
  1994.       k = n[0].kind;
  1995.  
  1996.       switch (k) {
  1997.      /* Frequently called functions: */
  1998.          case NODE_VERTEX:
  1999.             (*CC.VertexFunc)( n[1].f, n[2].f, n[3].f, n[4].f );
  2000.             break;
  2001.          case NODE_NORMAL:
  2002.             CC.Current.Normal[0] = n[1].f;
  2003.             CC.Current.Normal[1] = n[2].f;
  2004.             CC.Current.Normal[2] = n[3].f;
  2005.             break;
  2006.      case NODE_COLOR:
  2007.             CC.Current.IntColor[0] = n[1].i;
  2008.             CC.Current.IntColor[1] = n[2].i;
  2009.             CC.Current.IntColor[2] = n[3].i;
  2010.             CC.Current.IntColor[3] = n[4].i;
  2011.             if (CC.Light.ColorMaterialEnabled) {
  2012.                /* Translate this glColor() call into a glMaterial() call */
  2013.                GLfloat color[4];
  2014.                color[0] = n[1].i / CC.RedScale;
  2015.                color[1] = n[2].i / CC.GreenScale;
  2016.                color[2] = n[3].i / CC.BlueScale;
  2017.                color[3] = n[4].i / CC.AlphaScale;
  2018.                gl_material( CC.Light.ColorMaterialFace,
  2019.                             CC.Light.ColorMaterialMode, color );
  2020.             }
  2021.             VB.MonoColor = GL_FALSE;
  2022.         break;
  2023.          case NODE_INDEX:
  2024.             CC.Current.Index = n[1].ui;
  2025.             VB.MonoColor = GL_FALSE;
  2026.             break;
  2027.          case NODE_BEGIN:
  2028.             gl_begin( n[1].e );
  2029.             break;
  2030.          case NODE_END:
  2031.             gl_end();
  2032.             break;
  2033.      case NODE_TEXCOORD:
  2034.         CC.Current.TexCoord[0] = n[1].f;
  2035.         CC.Current.TexCoord[1] = n[2].f;
  2036.         CC.Current.TexCoord[2] = n[3].f;
  2037.         CC.Current.TexCoord[3] = n[4].f;
  2038.         break;
  2039.  
  2040.      /* Everything Else: */
  2041.          case NODE_ACCUM:
  2042.         gl_accum( n[1].e, n[2].f );
  2043.         break;
  2044.          case NODE_ALPHA_FUNC:
  2045.         glAlphaFunc( n[1].e, n[2].f );
  2046.         break;
  2047.      case NODE_BITMAP:
  2048.         gl_bitmap( (GLsizei) n[1].i, (GLsizei) n[2].i,
  2049.                n[3].f, n[4].f,
  2050.                n[5].f, n[6].f,
  2051.                (GLubyte *) n[7].data );
  2052.         break;
  2053.      case NODE_BLEND_COLOR:
  2054.         glBlendColorEXT( n[1].f, n[2].f, n[3].f, n[4].f );
  2055.         break;
  2056.      case NODE_BLEND_EQUATION:
  2057.         glBlendEquationEXT( n[1].e );
  2058.         break;
  2059.      case NODE_BLEND_FUNC:
  2060.         glBlendFunc( n[1].e, n[2].e );
  2061.         break;
  2062.          case NODE_CALL_LIST:
  2063.         /* Generated by glCallList(), don't add ListBase */
  2064.             if (CC.CallDepth<MAX_LIST_NESTING) {
  2065.                execute_list( n[1].ui );
  2066.             }
  2067.             break;
  2068.          case NODE_CALL_LIST_OFFSET:
  2069.         /* Generated by glCallLists() so we must add ListBase */
  2070.             if (CC.CallDepth<MAX_LIST_NESTING) {
  2071.                execute_list( CC.List.ListBase + n[1].ui );
  2072.             }
  2073.             break;
  2074.      case NODE_CLEAR:
  2075.         glClear( n[1].bf );
  2076.         break;
  2077.      case NODE_CLEAR_COLOR:
  2078.         glClearColor( n[1].f, n[2].f, n[3].f, n[4].f );
  2079.         break;
  2080.      case NODE_CLEAR_ACCUM:
  2081.         glClearAccum( n[1].f, n[2].f, n[3].f, n[4].f );
  2082.         break;
  2083.      case NODE_CLEAR_DEPTH:
  2084.         glClearDepth( (GLclampd) n[1].f );
  2085.         break;
  2086.      case NODE_CLEAR_INDEX:
  2087.         glClearIndex( n[1].ui );
  2088.         break;
  2089.      case NODE_CLEAR_STENCIL:
  2090.         glClearStencil( n[1].i );
  2091.         break;
  2092.          case NODE_CLIP_PLANE:
  2093.             {
  2094.                GLfloat equ[4];
  2095.                equ[0] = n[2].f;
  2096.                equ[1] = n[3].f;
  2097.                equ[2] = n[4].f;
  2098.                equ[3] = n[5].f;
  2099.                gl_clipplane( n[1].e, equ );
  2100.             }
  2101.             break;
  2102.      case NODE_COLOR_MASK:
  2103.         glColorMask( n[1].b, n[2].b, n[3].b, n[4].b );
  2104.         break;
  2105.      case NODE_COLOR_MATERIAL:
  2106.         glColorMaterial( n[1].e, n[2].e );
  2107.         break;
  2108.      case NODE_COPY_PIXELS:
  2109.         gl_copypixels( n[1].i, n[2].i,
  2110.                (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
  2111.         break;
  2112.      case NODE_CULL_FACE:
  2113.         glCullFace( n[1].e );
  2114.         break;
  2115.      case NODE_DEPTH_FUNC:
  2116.         glDepthFunc( n[1].e );
  2117.         break;
  2118.      case NODE_DEPTH_MASK:
  2119.         glDepthMask( n[1].b );
  2120.         break;
  2121.      case NODE_DEPTH_RANGE:
  2122.         glDepthRange( (GLclampd) n[1].f, (GLclampd) n[2].f );
  2123.         break;
  2124.      case NODE_DISABLE:
  2125.         gl_enable( n[1].e, GL_FALSE );
  2126.         break;
  2127.      case NODE_DRAW_BUFFER:
  2128.         glDrawBuffer( n[1].e );
  2129.         break;
  2130.      case NODE_DRAW_PIXELS:
  2131.         gl_drawpixels( (GLsizei) n[1].i, (GLsizei) n[2].i,
  2132.                n[3].e, n[4].e, n[5].data );
  2133.         break;
  2134.      case NODE_EDGE_FLAG:
  2135.             CC.Current.EdgeFlag = n[1].e;
  2136.             break;
  2137.      case NODE_ENABLE:
  2138.         gl_enable( n[1].e, GL_TRUE );
  2139.         break;
  2140.      case NODE_EVALCOORD1:
  2141.         gl_evalcoord1( n[1].f );
  2142.         break;
  2143.      case NODE_EVALCOORD2:
  2144.         gl_evalcoord2( n[1].f, n[2].f );
  2145.         break;
  2146.      case NODE_EVALMESH1:
  2147.         glEvalMesh1( n[1].e, n[2].i, n[3].i );
  2148.         break;
  2149.      case NODE_EVALMESH2:
  2150.         glEvalMesh2( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
  2151.         break;
  2152.      case NODE_EVALPOINT1:
  2153.         glEvalPoint1( n[1].i );
  2154.         break;
  2155.      case NODE_EVALPOINT2:
  2156.         glEvalPoint2( n[1].i, n[2].i );
  2157.         break;
  2158.      case NODE_FOG:
  2159.         {
  2160.            GLfloat p[4];
  2161.            p[0] = n[2].f;
  2162.            p[1] = n[3].f;
  2163.            p[2] = n[4].f;
  2164.            p[3] = n[5].f;
  2165.            gl_fog( n[1].e, p );
  2166.         }
  2167.         break;
  2168.      case NODE_FRONT_FACE:
  2169.         glFrontFace( n[1].e );
  2170.         break;
  2171.      case NODE_HINT:
  2172.         glHint( n[1].e, n[2].e );
  2173.         break;
  2174.      case NODE_INDEX_MASK:
  2175.         glIndexMask( n[1].ui );
  2176.         break;
  2177.      case NODE_INIT_NAMES:
  2178.         glInitNames();
  2179.         break;
  2180.          case NODE_LIGHT:
  2181.         {
  2182.            GLfloat p[4];
  2183.            p[0] = n[3].f;
  2184.            p[1] = n[4].f;
  2185.            p[2] = n[5].f;
  2186.            p[3] = n[6].f;
  2187.            gl_light( n[1].e, n[2].e, p );
  2188.         }
  2189.         break;
  2190.          case NODE_LIGHT_MODEL:
  2191.         {
  2192.            GLfloat p[4];
  2193.            p[0] = n[2].f;
  2194.            p[1] = n[3].f;
  2195.            p[2] = n[4].f;
  2196.            p[3] = n[5].f;
  2197.            gl_lightmodel( n[1].e, p );
  2198.         }
  2199.         break;
  2200.      case NODE_LINE_STIPPLE:
  2201.         glLineStipple( n[1].i, n[2].us );
  2202.         break;
  2203.      case NODE_LINE_WIDTH:
  2204.         glLineWidth( n[1].f );
  2205.         break;
  2206.      case NODE_LIST_BASE:
  2207.         glListBase( n[1].ui );
  2208.         break;
  2209.      case NODE_LOAD_MATRIX:
  2210.         if (sizeof(Node)==sizeof(GLfloat)) {
  2211.            gl_load_matrix( &n[1].f );
  2212.         }
  2213.         else {
  2214.            GLfloat m[16];
  2215.            GLuint i;
  2216.            for (i=0;i<16;i++) {
  2217.           m[i] = n[1+i].f;
  2218.            }
  2219.            gl_load_matrix( m );
  2220.         }
  2221.         break;
  2222.      case NODE_LOAD_NAME:
  2223.         glLoadName( n[1].ui );
  2224.         break;
  2225.      case NODE_LOGIC_OP:
  2226.         gl_logicop( n[1].e );
  2227.         break;
  2228.      case NODE_MAP1:
  2229.         gl_map1( n[1].e, n[2].f, n[3].f,
  2230.              n[4].i, n[5].i, (GLfloat *) n[6].data );
  2231.         break;
  2232.      case NODE_MAP2:
  2233.         gl_map2( n[1].e,
  2234.              n[2].f, n[3].f,  /* u1, u2 */
  2235.              n[6].i, n[8].i,  /* ustride, uorder */
  2236.              n[4].f, n[5].f,  /* v1, v2 */
  2237.              n[7].i, n[9].i,  /* vstride, vorder */
  2238.              (GLfloat *) n[10].data );
  2239.         break;
  2240.      case NODE_MAPGRID1:
  2241.         gl_mapgrid1( n[1].i, n[2].f, n[3].f );
  2242.         break;
  2243.      case NODE_MAPGRID2:
  2244.         gl_mapgrid2( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f );
  2245.         break;
  2246.      case NODE_MATERIAL:
  2247.         {
  2248.            GLfloat params[4];
  2249.            params[0] = n[3].f;
  2250.            params[1] = n[4].f;
  2251.            params[2] = n[5].f;
  2252.            params[3] = n[6].f;
  2253.            gl_material( n[1].e, n[2].e, params );
  2254.         }
  2255.         break;
  2256.          case NODE_MATRIX_MODE:
  2257.             glMatrixMode( n[1].e );
  2258.             break;
  2259.      case NODE_MULT_MATRIX:
  2260.         if (sizeof(Node)==sizeof(GLfloat)) {
  2261.            gl_mult_matrix( &n[1].f );
  2262.         }
  2263.         else {
  2264.            GLfloat m[16];
  2265.            GLuint i;
  2266.            for (i=0;i<16;i++) {
  2267.           m[i] = n[1+i].f;
  2268.            }
  2269.            gl_mult_matrix( m );
  2270.         }
  2271.         break;
  2272.      case NODE_PASSTHROUGH:
  2273.         gl_passthrough( n[1].f );
  2274.         break;
  2275.      case NODE_PIXEL_MAP:
  2276.         gl_pixel_map( n[1].e, n[2].i, (GLfloat *) n[3].data );
  2277.         break;
  2278.      case NODE_PIXEL_TRANSFER:
  2279.         gl_pixel_transfer( n[1].e, n[2].f );
  2280.         break;
  2281.      case NODE_PIXEL_ZOOM:
  2282.         glPixelZoom( n[1].f, n[2].f );
  2283.         break;
  2284.      case NODE_POINTSIZE:
  2285.         glPointSize( n[1].f );
  2286.         break;
  2287.      case NODE_POLYGON_MODE:
  2288.         glPolygonMode( n[1].e, n[2].e );
  2289.         break;
  2290.      case NODE_POLYGON_OFFSET:
  2291.         glPolygonOffsetEXT( n[1].f, n[2].f );
  2292.         break;
  2293.      case NODE_POP_ATTRIB:
  2294.         gl_pop_attrib();
  2295.         break;
  2296.      case NODE_POP_MATRIX:
  2297.         glPopMatrix();
  2298.         break;
  2299.      case NODE_POP_NAME:
  2300.         glPopName();
  2301.         break;
  2302.      case NODE_PUSH_ATTRIB:
  2303.         gl_push_attrib( n[1].bf );
  2304.         break;
  2305.      case NODE_PUSH_MATRIX:
  2306.         glPushMatrix();
  2307.         break;
  2308.      case NODE_PUSH_NAME:
  2309.         glPushName( n[1].ui );
  2310.         break;
  2311.      case NODE_RASTER_POS:
  2312.         {
  2313.            GLfloat v[4];
  2314.            v[0] = n[1].f;
  2315.            v[1] = n[2].f;
  2316.            v[2] = n[3].f;
  2317.            v[3] = n[4].f;
  2318.            gl_rasterpos( v );
  2319.         }
  2320.         break;
  2321.      case NODE_READ_BUFFER:
  2322.         glReadBuffer( n[1].e );
  2323.         break;
  2324.          case NODE_SCALE:
  2325.             gl_scale( n[1].f, n[2].f, n[3].f );
  2326.             break;
  2327.      case NODE_SCISSOR:
  2328.         glScissor( n[1].i, n[2].i, n[3].i, n[4].i );
  2329.         break;
  2330.      case NODE_SHADE_MODEL:
  2331.         glShadeModel( n[1].e );
  2332.         break;
  2333.      case NODE_STENCIL_FUNC:
  2334.         glStencilFunc( n[1].e, n[2].i, n[3].ui );
  2335.         break;
  2336.      case NODE_STENCIL_MASK:
  2337.         glStencilMask( n[1].ui );
  2338.         break;
  2339.      case NODE_STENCIL_OP:
  2340.         glStencilOp( n[1].e, n[2].e, n[3].e );
  2341.         break;
  2342.          case NODE_TEXENV:
  2343.             {
  2344.                GLfloat params[4];
  2345.                params[0] = n[3].f;
  2346.                params[1] = n[4].f;
  2347.                params[2] = n[5].f;
  2348.                params[3] = n[6].f;
  2349.                gl_texenv( n[1].e, n[2].e, params );
  2350.             }
  2351.             break;
  2352.          case NODE_TEXGEN:
  2353.             {
  2354.                GLfloat params[4];
  2355.                params[0] = n[3].f;
  2356.                params[1] = n[4].f;
  2357.                params[2] = n[5].f;
  2358.                params[3] = n[6].f;
  2359.                gl_texgen( n[1].e, n[2].e, params );
  2360.             }
  2361.             break;
  2362.          case NODE_TEXPARAMETER:
  2363.             {
  2364.                GLfloat params[4];
  2365.                params[0] = n[3].f;
  2366.                params[1] = n[4].f;
  2367.                params[2] = n[5].f;
  2368.                params[3] = n[6].f;
  2369.                gl_texparameter( n[1].e, n[2].e, params );
  2370.             }
  2371.             break;
  2372.      case NODE_TEXIMAGE1D:
  2373.         gl_teximage1d( n[1].i, n[2].i, n[3].i, n[4].i,
  2374.                            (GLubyte *) n[5].data );
  2375.         break;
  2376.      case NODE_TEXIMAGE2D:
  2377.         gl_teximage2d( n[1].i, n[2].i, n[3].i, n[4].i, n[5].i,
  2378.                            (GLubyte *) n[6].data );
  2379.         break;
  2380.          case NODE_TRANSLATE:
  2381.             gl_translate( n[1].f, n[2].f, n[3].f );
  2382.             break;
  2383.      case NODE_VIEWPORT:
  2384.         gl_viewport( n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
  2385.         break;
  2386.      case NODE_WINDOW_POS:
  2387.             gl_windowpos( n[1].f, n[2].f, n[3].f, n[4].f );
  2388.         break;
  2389.      case NODE_CONTINUE:
  2390.         n = (Node *) n[1].next;
  2391.         break;
  2392.      case NODE_END_OF_LIST:
  2393.         done = GL_TRUE;
  2394.         break;
  2395.      default:
  2396.         printf("Error in execute_list: %d\n", (int) k );
  2397.         gl_error( GL_INVALID_ENUM, "execute_list" );
  2398.       }
  2399.  
  2400.       /* increment n to point to next compiled command */
  2401.       if (k!=NODE_CONTINUE) {
  2402.      n += NodeSize[k];
  2403.       }
  2404.  
  2405.    }
  2406.    CC.CallDepth--;
  2407. }
  2408.  
  2409.  
  2410.  
  2411. /**********************************************************************/
  2412. /*                           GL functions                             */
  2413. /**********************************************************************/
  2414.  
  2415.  
  2416.  
  2417. /*
  2418.  * Test if a display list number is valid.
  2419.  */
  2420. GLboolean glIsList( GLuint list )
  2421. {
  2422.    if (list>0 && CC.ListGroup->List[list-1]) {
  2423.       return GL_TRUE;
  2424.    }
  2425.    else {
  2426.       return GL_FALSE;
  2427.    }
  2428. }
  2429.  
  2430.  
  2431.  
  2432. /*
  2433.  * Delete a sequence of consecutive display lists.
  2434.  */
  2435. void glDeleteLists( GLuint list, GLsizei range )
  2436. {
  2437.    GLuint i;
  2438.  
  2439.    if (INSIDE_BEGIN_END) {
  2440.       gl_error( GL_INVALID_OPERATION, "glDeleteLists" );
  2441.       return;
  2442.    }
  2443.    if (range<0) {
  2444.       gl_error( GL_INVALID_VALUE, "glDeleteLists" );
  2445.       return;
  2446.    }
  2447.    for (i=list;i<list+range;i++) {
  2448.       if (i<=MAX_DISPLAYLISTS && CC.ListGroup->List[i-1]) {
  2449.          destroy_list( i-1 );
  2450.          CC.ListGroup->List[i-1] = NULL;
  2451.       }
  2452.    }
  2453. }
  2454.  
  2455.  
  2456.  
  2457. /*
  2458.  * Return a display list number, n, such that lists n through n+range-1
  2459.  * are free.
  2460.  */
  2461. GLuint glGenLists( GLsizei range )
  2462. {
  2463.    GLuint i, freecount;
  2464.  
  2465.    if (INSIDE_BEGIN_END) {
  2466.       gl_error( GL_INVALID_OPERATION, "glGenLists" );
  2467.       return 0;
  2468.    }
  2469.    if (range<=0) {
  2470.       gl_error( GL_INVALID_VALUE, "glGenLists" );
  2471.       return 0;
  2472.    }
  2473.  
  2474.    i = 0;
  2475.    freecount = 0;
  2476.    for (i=0; i<MAX_DISPLAYLISTS; i++ ) {
  2477.       if (CC.ListGroup->List[i]==NULL) {
  2478.          freecount++;
  2479.          if (freecount==range) {
  2480.         /* We found 'range' consecutive free lists. */
  2481.             /* Now reserve the IDs with empty display lists. */
  2482.         GLuint k;
  2483.         GLuint n = i-range+2;
  2484.         for (k=n;k<n+range;k++) {
  2485.            CC.ListGroup->List[k-1] = make_empty_list();
  2486.         }
  2487.             return n;
  2488.          }
  2489.       }
  2490.       else {
  2491.          freecount = 0;
  2492.       }
  2493.    }
  2494.    return 0;
  2495. }
  2496.  
  2497.  
  2498.  
  2499. /*
  2500.  * Begin a new display list.
  2501.  */
  2502. void glNewList( GLuint list, GLenum mode )
  2503. {
  2504.    if (INSIDE_BEGIN_END) {
  2505.       gl_error( GL_INVALID_OPERATION, "glNewList" );
  2506.       return;
  2507.    }
  2508.    if (list==0 || list>MAX_DISPLAYLISTS) {
  2509.       gl_error( GL_INVALID_VALUE, "glNewList" );
  2510.       return;
  2511.    }
  2512.    if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
  2513.       gl_error( GL_INVALID_ENUM, "glNewList" );
  2514.       return;
  2515.    }
  2516.    if (CurrentListPtr) {
  2517.       /* already compiling a display list */
  2518.       gl_error( GL_INVALID_OPERATION, "glNewList" );
  2519.       return;
  2520.    }
  2521.  
  2522.    /* Allocate new display list */
  2523.    CurrentListNum = list;
  2524.    CurrentListPtr = CurrentBlock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
  2525.    CurrentPos = 0;
  2526.  
  2527.    CC.CompileFlag = GL_TRUE;
  2528.    if (mode==GL_COMPILE) {
  2529.       CC.ExecuteFlag = GL_FALSE;
  2530.       CC.VertexFunc = gl_save_vertex;
  2531.    }
  2532.    else {
  2533.       /* Compile and execute */
  2534.       CC.ExecuteFlag = GL_TRUE;
  2535.       CC.VertexFunc = gl_save_and_execute_vertex;
  2536.    }
  2537. }
  2538.  
  2539.  
  2540.  
  2541. /*
  2542.  * End definition of current display list.
  2543.  */
  2544. void glEndList( void )
  2545. {
  2546.    Node *n;
  2547.  
  2548.    /* Check that a list is under construction */
  2549.    if (!CurrentListPtr) {
  2550.       gl_error( GL_INVALID_OPERATION, "glEndList" );
  2551.       return;
  2552.    }
  2553.  
  2554.    n = alloc_nodes(1);
  2555.    n[0].kind = NODE_END_OF_LIST;
  2556.  
  2557.    /* Install the list */
  2558.    if (CC.ListGroup->List[CurrentListNum-1]) {
  2559.       destroy_list( CurrentListNum-1 );
  2560.    }
  2561.    CC.ListGroup->List[CurrentListNum-1] = CurrentListPtr;
  2562.  
  2563.    CurrentListNum = 0;
  2564.    CurrentListPtr = NULL;
  2565.    CC.ExecuteFlag = GL_TRUE;
  2566.    CC.CompileFlag = GL_FALSE;
  2567.    CC.VertexFunc = gl_nop_vertex;
  2568. }
  2569.  
  2570.  
  2571.  
  2572. void glCallList( GLuint list )
  2573. {
  2574.    if (CC.CompileFlag) {
  2575.       gl_save_call( list );
  2576.    }
  2577.    if (CC.ExecuteFlag) {
  2578.       /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
  2579.       /* execute the display list, and restore the CompileFlag. */
  2580.       GLboolean save_compile_flag;
  2581.       save_compile_flag = CC.CompileFlag;
  2582.       CC.CompileFlag = GL_FALSE;
  2583.       execute_list( list );
  2584.       CC.CompileFlag = save_compile_flag;
  2585.    }
  2586. }
  2587.  
  2588.  
  2589.  
  2590. /*
  2591.  * Call multiple display lists.
  2592.  */
  2593. void glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
  2594. {
  2595.    GLuint i, list;
  2596.  
  2597.    if (CC.CompileFlag) {
  2598.       for (i=0;i<n;i++) {
  2599.      list = translate_id( i, type, lists );
  2600.      gl_save_call_offset( list );
  2601.       }
  2602.    }
  2603.  
  2604.    if (CC.ExecuteFlag) {
  2605.       /* Save the CompileFlag status, turn it off, execute display list, */
  2606.       /* and restore the CompileFlag. */
  2607.       GLboolean save_compile_flag;
  2608.       save_compile_flag = CC.CompileFlag;
  2609.       CC.CompileFlag = GL_FALSE;
  2610.       for (i=0;i<n;i++) {
  2611.      list = translate_id( i, type, lists );
  2612.      execute_list( CC.List.ListBase + list );
  2613.       }
  2614.       CC.CompileFlag = save_compile_flag;
  2615.    }
  2616. }
  2617.  
  2618.  
  2619.  
  2620. /*
  2621.  * Set the offset added to list numbers in glCallLists.
  2622.  */
  2623. void glListBase( GLuint base )
  2624. {
  2625.    if (CC.CompileFlag) {
  2626.       gl_save_listbase( base );
  2627.    }
  2628.    if (CC.ExecuteFlag) {
  2629.       if (INSIDE_BEGIN_END) {
  2630.      gl_error( GL_INVALID_OPERATION, "glListBase" );
  2631.      return;
  2632.       }
  2633.       CC.List.ListBase = base;
  2634.    }
  2635. }
  2636.  
  2637.  
  2638.  
  2639. char *gl_enumstr( GLenum n )
  2640. {
  2641.    switch (n) {
  2642.       case GL_POINTS:
  2643.          return "GL_POINTS";
  2644.       case GL_LINES:
  2645.          return "GL_LINES";
  2646.       case GL_LINE_STRIP:
  2647.          return "GL_LINE_STRIP";
  2648.       case GL_LINE_LOOP:
  2649.          return "GL_LINE_LOOP";
  2650.       case GL_TRIANGLES:
  2651.          return "GL_TRIANGLES";
  2652.       case GL_TRIANGLE_STRIP:
  2653.          return "GL_TRIANGLE_STRIP";
  2654.       case GL_TRIANGLE_FAN:
  2655.          return "GL_TRIANGLE_FAN";
  2656.       case GL_QUADS:
  2657.          return "GL_QUADS";
  2658.       case GL_QUAD_STRIP:
  2659.          return "GL_QUAD_STRIP";
  2660.       case GL_POLYGON:
  2661.          return "GL_POLYGON";
  2662.       default:
  2663.          return "enum";
  2664.    }
  2665. }
  2666.  
  2667.  
  2668. /*
  2669.  * Print the commands in a display list.  For debugging only.
  2670.  */
  2671. void gl_print_list( GLuint list )
  2672. {
  2673.    Node *n;
  2674.    GLboolean done;
  2675.    Kind k;
  2676.  
  2677.    if (!glIsList(list))
  2678.       return;
  2679.  
  2680.    n = CC.ListGroup->List[list-1];
  2681.    done = GL_FALSE;
  2682.    while (!done) {
  2683.       k = n[0].kind;
  2684.  
  2685.       switch (k) {
  2686.      /* Frequently called functions: */
  2687.          case NODE_VERTEX:
  2688.             printf("vertex %g %g %g %g\n", n[1].f, n[2].f, n[3].f, n[4].f );
  2689.             break;
  2690.          case NODE_NORMAL:
  2691.             printf("normal %g %g %g\n", n[1].f, n[2].f, n[3].f );
  2692.             break;
  2693.      case NODE_COLOR:
  2694.             printf("color %d %d %d %d\n", n[1].i, n[2].i, n[3].i, n[4].i );
  2695.         break;
  2696.          case NODE_INDEX:
  2697.             printf("index %d\n", n[1].ui );
  2698.             break;
  2699.          case NODE_BEGIN:
  2700.             printf("begin %s\n", gl_enumstr(n[1].e) );
  2701.             break;
  2702.          case NODE_END:
  2703.             printf("end\n");
  2704.             break;
  2705.      case NODE_TEXCOORD:
  2706.             printf("texcoord %g %g %g %g\n", n[1].f, n[2].f, n[3].f, n[4].f );
  2707.         break;
  2708.          case NODE_ACCUM:
  2709.             printf("accum %d %g\n", n[1].e, n[2].f );
  2710.         break;
  2711. #ifdef LEAVEOUT
  2712.          case NODE_ALPHA_FUNC:
  2713.         glAlphaFunc( n[1].e, n[2].f );
  2714.         break;
  2715.      case NODE_BITMAP:
  2716.         gl_bitmap( (GLsizei) n[1].i, (GLsizei) n[2].i,
  2717.                n[3].f, n[4].f,
  2718.                n[5].f, n[6].f,
  2719.                (GLubyte *) n[7].data );
  2720.         break;
  2721.      case NODE_BLEND_COLOR:
  2722.         glBlendColorEXT( n[1].f, n[2].f, n[3].f, n[4].f );
  2723.         break;
  2724.      case NODE_BLEND_EQUATION:
  2725.         glBlendEquationEXT( n[1].e );
  2726.         break;
  2727.      case NODE_BLEND_FUNC:
  2728.         glBlendFunc( n[1].e, n[2].e );
  2729.         break;
  2730. #endif
  2731.          case NODE_CALL_LIST:
  2732.             printf("call list %d\n", n[1].ui );
  2733.             break;
  2734.          case NODE_CALL_LIST_OFFSET:
  2735.             printf("call list %d+%d\n", CC.List.ListBase, n[1].ui );
  2736.             break;
  2737.      case NODE_CLEAR:
  2738.             printf("clear %x\n", (int) n[1].bf );
  2739.         break;
  2740. #ifdef LEAVEOUT
  2741.      case NODE_CLEAR_COLOR:
  2742.         glClearColor( n[1].f, n[2].f, n[3].f, n[4].f );
  2743.         break;
  2744.      case NODE_CLEAR_ACCUM:
  2745.         glClearAccum( n[1].f, n[2].f, n[3].f, n[4].f );
  2746.         break;
  2747.      case NODE_CLEAR_DEPTH:
  2748.         glClearDepth( (GLclampd) n[1].f );
  2749.         break;
  2750.      case NODE_CLEAR_INDEX:
  2751.         glClearIndex( n[1].ui );
  2752.         break;
  2753.      case NODE_CLEAR_STENCIL:
  2754.         glClearStencil( n[1].i );
  2755.         break;
  2756.          case NODE_CLIP_PLANE:
  2757.             {
  2758.                GLfloat equ[4];
  2759.                equ[0] = n[2].f;
  2760.                equ[1] = n[3].f;
  2761.                equ[2] = n[4].f;
  2762.                equ[3] = n[5].f;
  2763.                gl_clipplane( n[1].e, equ );
  2764.             }
  2765.             break;
  2766.      case NODE_COLOR_MASK:
  2767.         glColorMask( n[1].b, n[2].b, n[3].b, n[4].b );
  2768.         break;
  2769.      case NODE_COLOR_MATERIAL:
  2770.         glColorMaterial( n[1].e, n[2].e );
  2771.         break;
  2772.      case NODE_COPY_PIXELS:
  2773.         gl_copypixels( n[1].i, n[2].i,
  2774.                (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
  2775.         break;
  2776.      case NODE_CULL_FACE:
  2777.         glCullFace( n[1].e );
  2778.         break;
  2779.      case NODE_DEPTH_FUNC:
  2780.         glDepthFunc( n[1].e );
  2781.         break;
  2782.      case NODE_DEPTH_MASK:
  2783.         glDepthMask( n[1].b );
  2784.         break;
  2785.      case NODE_DEPTH_RANGE:
  2786.         glDepthRange( (GLclampd) n[1].f, (GLclampd) n[2].f );
  2787.         break;
  2788.      case NODE_DISABLE:
  2789.         gl_enable( n[1].e, GL_FALSE );
  2790.         break;
  2791.      case NODE_DRAW_BUFFER:
  2792.         glDrawBuffer( n[1].e );
  2793.         break;
  2794.      case NODE_DRAW_PIXELS:
  2795.         gl_drawpixels( (GLsizei) n[1].i, (GLsizei) n[2].i,
  2796.                n[3].e, n[4].e, n[5].data );
  2797.         break;
  2798.      case NODE_EDGE_FLAG:
  2799.             CC.Current.EdgeFlag = n[1].e;
  2800.             break;
  2801.      case NODE_ENABLE:
  2802.         gl_enable( n[1].e, GL_TRUE );
  2803.         break;
  2804.      case NODE_EVALCOORD1:
  2805.         gl_evalcoord1( n[1].f );
  2806.         break;
  2807.      case NODE_EVALCOORD2:
  2808.         gl_evalcoord2( n[1].f, n[2].f );
  2809.         break;
  2810.      case NODE_EVALMESH1:
  2811.         glEvalMesh1( n[1].e, n[2].i, n[3].i );
  2812.         break;
  2813.      case NODE_EVALMESH2:
  2814.         glEvalMesh2( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
  2815.         break;
  2816.      case NODE_EVALPOINT1:
  2817.         glEvalPoint1( n[1].i );
  2818.         break;
  2819.      case NODE_EVALPOINT2:
  2820.         glEvalPoint2( n[1].i, n[2].i );
  2821.         break;
  2822.      case NODE_FOG:
  2823.         {
  2824.            GLfloat p[4];
  2825.            p[0] = n[2].f;
  2826.            p[1] = n[3].f;
  2827.            p[2] = n[4].f;
  2828.            p[3] = n[5].f;
  2829.            gl_fog( n[1].e, p );
  2830.         }
  2831.         break;
  2832.      case NODE_FRONT_FACE:
  2833.         glFrontFace( n[1].e );
  2834.         break;
  2835.      case NODE_HINT:
  2836.         glHint( n[1].e, n[2].e );
  2837.         break;
  2838.      case NODE_INDEX_MASK:
  2839.         glIndexMask( n[1].ui );
  2840.         break;
  2841.      case NODE_INIT_NAMES:
  2842.         glInitNames();
  2843.         break;
  2844.          case NODE_LIGHT:
  2845.         {
  2846.            GLfloat p[4];
  2847.            p[0] = n[3].f;
  2848.            p[1] = n[4].f;
  2849.            p[2] = n[5].f;
  2850.            p[3] = n[6].f;
  2851.            gl_light( n[1].e, n[2].e, p );
  2852.         }
  2853.         break;
  2854.          case NODE_LIGHT_MODEL:
  2855.         {
  2856.            GLfloat p[4];
  2857.            p[0] = n[2].f;
  2858.            p[1] = n[3].f;
  2859.            p[2] = n[4].f;
  2860.            p[3] = n[5].f;
  2861.            gl_lightmodel( n[1].e, p );
  2862.         }
  2863.         break;
  2864.      case NODE_LINE_STIPPLE:
  2865.         glLineStipple( n[1].i, n[2].us );
  2866.         break;
  2867.      case NODE_LINE_WIDTH:
  2868.         glLineWidth( n[1].f );
  2869.         break;
  2870.      case NODE_LIST_BASE:
  2871.         glListBase( n[1].ui );
  2872.         break;
  2873.      case NODE_LOAD_MATRIX:
  2874.         if (sizeof(Node)==sizeof(GLfloat)) {
  2875.            gl_load_matrix( &n[1].f );
  2876.         }
  2877.         else {
  2878.            GLfloat m[16];
  2879.            GLuint i;
  2880.            for (i=0;i<16;i++) {
  2881.           m[i] = n[1+i].f;
  2882.            }
  2883.            gl_load_matrix( m );
  2884.         }
  2885.         break;
  2886.      case NODE_LOAD_NAME:
  2887.         glLoadName( n[1].ui );
  2888.         break;
  2889.      case NODE_LOGIC_OP:
  2890.         gl_logicop( n[1].e );
  2891.         break;
  2892.      case NODE_MAP1:
  2893.         gl_map1( n[1].e, n[2].f, n[3].f,
  2894.              n[4].i, n[5].i, (GLfloat *) n[6].data );
  2895.         break;
  2896.      case NODE_MAP2:
  2897.         gl_map2( n[1].e,
  2898.              n[2].f, n[3].f,  /* u1, u2 */
  2899.              n[6].i, n[8].i,  /* ustride, uorder */
  2900.              n[4].f, n[5].f,  /* v1, v2 */
  2901.              n[7].i, n[9].i,  /* vstride, vorder */
  2902.              (GLfloat *) n[10].data );
  2903.         break;
  2904.      case NODE_MAPGRID1:
  2905.         gl_mapgrid1( n[1].i, n[2].f, n[3].f );
  2906.         break;
  2907.      case NODE_MAPGRID2:
  2908.         gl_mapgrid2( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f );
  2909.         break;
  2910.      case NODE_MATERIAL:
  2911.         {
  2912.            GLfloat params[4];
  2913.            params[0] = n[3].f;
  2914.            params[1] = n[4].f;
  2915.            params[2] = n[5].f;
  2916.            params[3] = n[6].f;
  2917.            gl_material( n[1].e, n[2].e, params );
  2918.         }
  2919.         break;
  2920.          case NODE_MATRIX_MODE:
  2921.             glMatrixMode( n[1].e );
  2922.             break;
  2923.      case NODE_MULT_MATRIX:
  2924.         if (sizeof(Node)==sizeof(GLfloat)) {
  2925.            gl_mult_matrix( &n[1].f );
  2926.         }
  2927.         else {
  2928.            GLfloat m[16];
  2929.            GLuint i;
  2930.            for (i=0;i<16;i++) {
  2931.           m[i] = n[1+i].f;
  2932.            }
  2933.            gl_mult_matrix( m );
  2934.         }
  2935.         break;
  2936.      case NODE_PASSTHROUGH:
  2937.         gl_passthrough( n[1].f );
  2938.         break;
  2939.      case NODE_PIXEL_MAP:
  2940.         gl_pixel_map( n[1].e, n[2].i, (GLfloat *) n[3].data );
  2941.         break;
  2942.      case NODE_PIXEL_TRANSFER:
  2943.         gl_pixel_transfer( n[1].e, n[2].f );
  2944.         break;
  2945.      case NODE_PIXEL_ZOOM:
  2946.         glPixelZoom( n[1].f, n[2].f );
  2947.         break;
  2948.      case NODE_POINTSIZE:
  2949.         glPointSize( n[1].f );
  2950.         break;
  2951.      case NODE_POLYGON_MODE:
  2952.         glPolygonMode( n[1].e, n[2].e );
  2953.         break;
  2954.      case NODE_POLYGON_OFFSET:
  2955.         glPolygonOffsetEXT( n[1].f, n[2].f );
  2956.         break;
  2957.      case NODE_POP_ATTRIB:
  2958.         gl_pop_attrib();
  2959.         break;
  2960.      case NODE_POP_MATRIX:
  2961.         glPopMatrix();
  2962.         break;
  2963.      case NODE_POP_NAME:
  2964.         glPopName();
  2965.         break;
  2966.      case NODE_PUSH_ATTRIB:
  2967.         gl_push_attrib( n[1].bf );
  2968.         break;
  2969.      case NODE_PUSH_MATRIX:
  2970.         glPushMatrix();
  2971.         break;
  2972.      case NODE_PUSH_NAME:
  2973.         glPushName( n[1].ui );
  2974.         break;
  2975.      case NODE_RASTER_POS:
  2976.         {
  2977.            GLfloat v[4];
  2978.            v[0] = n[1].f;
  2979.            v[1] = n[2].f;
  2980.            v[2] = n[3].f;
  2981.            v[3] = n[4].f;
  2982.            gl_rasterpos( v );
  2983.         }
  2984.         break;
  2985.      case NODE_READ_BUFFER:
  2986.         glReadBuffer( n[1].e );
  2987.         break;
  2988.          case NODE_SCALE:
  2989.             gl_scale( n[1].f, n[2].f, n[3].f );
  2990.             break;
  2991.      case NODE_SCISSOR:
  2992.         glScissor( n[1].i, n[2].i, n[3].i, n[4].i );
  2993.         break;
  2994.      case NODE_SHADE_MODEL:
  2995.         glShadeModel( n[1].e );
  2996.         break;
  2997.      case NODE_STENCIL_FUNC:
  2998.         glStencilFunc( n[1].e, n[2].i, n[3].ui );
  2999.         break;
  3000.      case NODE_STENCIL_MASK:
  3001.         glStencilMask( n[1].ui );
  3002.         break;
  3003.      case NODE_STENCIL_OP:
  3004.         glStencilOp( n[1].e, n[2].e, n[3].e );
  3005.         break;
  3006.          case NODE_TEXENV:
  3007.             {
  3008.                GLfloat params[4];
  3009.                params[0] = n[3].f;
  3010.                params[1] = n[4].f;
  3011.                params[2] = n[5].f;
  3012.                params[3] = n[6].f;
  3013.                gl_texenv( n[1].e, n[2].e, params );
  3014.             }
  3015.             break;
  3016.          case NODE_TEXGEN:
  3017.             {
  3018.                GLfloat params[4];
  3019.                params[0] = n[3].f;
  3020.                params[1] = n[4].f;
  3021.                params[2] = n[5].f;
  3022.                params[3] = n[6].f;
  3023.                gl_texgen( n[1].e, n[2].e, params );
  3024.             }
  3025.             break;
  3026.          case NODE_TEXPARAMETER:
  3027.             {
  3028.                GLfloat params[4];
  3029.                params[0] = n[3].f;
  3030.                params[1] = n[4].f;
  3031.                params[2] = n[5].f;
  3032.                params[3] = n[6].f;
  3033.                gl_texparameter( n[1].e, n[2].e, params );
  3034.             }
  3035.             break;
  3036.      case NODE_TEXIMAGE1D:
  3037.         gl_teximage1d( n[1].i, n[2].i, n[3].i, n[4].i,
  3038.                            (GLubyte *) n[5].data );
  3039.         break;
  3040.      case NODE_TEXIMAGE2D:
  3041.         gl_teximage2d( n[1].i, n[2].i, n[3].i, n[4].i, n[5].i,
  3042.                            (GLubyte *) n[6].data );
  3043.         break;
  3044.          case NODE_TRANSLATE:
  3045.             gl_translate( n[1].f, n[2].f, n[3].f );
  3046.             break;
  3047.      case NODE_VIEWPORT:
  3048.         gl_viewport( n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
  3049.         break;
  3050. #endif
  3051.      case NODE_CONTINUE:
  3052.             printf("CONTINUATION\n");
  3053.         n = (Node *) n[1].next;
  3054.         break;
  3055.      case NODE_END_OF_LIST:
  3056.             printf("END OF LIST\n");
  3057.         done = GL_TRUE;
  3058.         break;
  3059. #ifdef LEAVEOUT
  3060.      default:
  3061.         printf("Error in execute_list: %d\n", (int) k );
  3062.         gl_error( GL_INVALID_ENUM, "execute_list" );
  3063. #endif
  3064.          default:
  3065.             printf("OTHER (%d operands)\n", NodeSize[k] );
  3066.       }
  3067.  
  3068.       /* increment n to point to next compiled command */
  3069.       if (k!=NODE_CONTINUE) {
  3070.      n += NodeSize[k];
  3071.       }
  3072.  
  3073.    }
  3074. }
  3075.